', body_html)
+ self.assertNotIn("
")
+ self.assertEqual(repr(self.a2.get_next_by_pub_date()), "")
+ self.assertEqual(
+ repr(self.a2.get_next_by_pub_date(headline__endswith="6")),
+ "",
+ )
+ self.assertEqual(repr(self.a3.get_next_by_pub_date()), "")
+ self.assertEqual(repr(self.a4.get_next_by_pub_date()), "")
+ with self.assertRaises(Article.DoesNotExist):
+ self.a5.get_next_by_pub_date()
+ self.assertEqual(repr(self.a6.get_next_by_pub_date()), "")
+ self.assertEqual(repr(self.a7.get_next_by_pub_date()), "")
+
+ self.assertEqual(
+ repr(self.a7.get_previous_by_pub_date()), ""
+ )
+ self.assertEqual(
+ repr(self.a6.get_previous_by_pub_date()), ""
+ )
+ self.assertEqual(
+ repr(self.a5.get_previous_by_pub_date()), ""
+ )
+ self.assertEqual(
+ repr(self.a4.get_previous_by_pub_date()), ""
+ )
+ self.assertEqual(
+ repr(self.a3.get_previous_by_pub_date()), ""
+ )
+ self.assertEqual(
+ repr(self.a2.get_previous_by_pub_date()), ""
+ )
+
+ def test_escaping(self):
+ # Underscores, percent signs and backslashes have special meaning in the
+ # underlying SQL code, but Django handles the quoting of them automatically.
+ a8 = Article.objects.create(
+ headline="Article_ with underscore", pub_date=datetime(2005, 11, 20)
+ )
+
+ self.assertSequenceEqual(
+ Article.objects.filter(headline__startswith="Article"),
+ [a8, self.a5, self.a6, self.a4, self.a2, self.a3, self.a7, self.a1],
+ )
+ self.assertSequenceEqual(
+ Article.objects.filter(headline__startswith="Article_"),
+ [a8],
+ )
+ a9 = Article.objects.create(
+ headline="Article% with percent sign", pub_date=datetime(2005, 11, 21)
+ )
+ self.assertSequenceEqual(
+ Article.objects.filter(headline__startswith="Article"),
+ [a9, a8, self.a5, self.a6, self.a4, self.a2, self.a3, self.a7, self.a1],
+ )
+ self.assertSequenceEqual(
+ Article.objects.filter(headline__startswith="Article%"),
+ [a9],
+ )
+ a10 = Article.objects.create(
+ headline="Article with \\ backslash", pub_date=datetime(2005, 11, 22)
+ )
+ self.assertSequenceEqual(
+ Article.objects.filter(headline__contains="\\"),
+ [a10],
+ )
+
+ def test_exclude(self):
+ a8 = Article.objects.create(
+ headline="Article_ with underscore", pub_date=datetime(2005, 11, 20)
+ )
+ a9 = Article.objects.create(
+ headline="Article% with percent sign", pub_date=datetime(2005, 11, 21)
+ )
+ a10 = Article.objects.create(
+ headline="Article with \\ backslash", pub_date=datetime(2005, 11, 22)
+ )
+ # exclude() is the opposite of filter() when doing lookups:
+ self.assertSequenceEqual(
+ Article.objects.filter(headline__contains="Article").exclude(
+ headline__contains="with"
+ ),
+ [self.a5, self.a6, self.a4, self.a2, self.a3, self.a7, self.a1],
+ )
+ self.assertSequenceEqual(
+ Article.objects.exclude(headline__startswith="Article_"),
+ [a10, a9, self.a5, self.a6, self.a4, self.a2, self.a3, self.a7, self.a1],
+ )
+ self.assertSequenceEqual(
+ Article.objects.exclude(headline="Article 7"),
+ [a10, a9, a8, self.a5, self.a6, self.a4, self.a2, self.a3, self.a1],
+ )
+
+ def test_none(self):
+ # none() returns a QuerySet that behaves like any other QuerySet object
+ self.assertSequenceEqual(Article.objects.none(), [])
+ self.assertSequenceEqual(
+ Article.objects.none().filter(headline__startswith="Article"), []
+ )
+ self.assertSequenceEqual(
+ Article.objects.filter(headline__startswith="Article").none(), []
+ )
+ self.assertEqual(Article.objects.none().count(), 0)
+ self.assertEqual(
+ Article.objects.none().update(headline="This should not take effect"), 0
+ )
+ self.assertSequenceEqual(list(Article.objects.none().iterator()), [])
+
+ def test_in(self):
+ self.assertSequenceEqual(
+ Article.objects.exclude(id__in=[]),
+ [self.a5, self.a6, self.a4, self.a2, self.a3, self.a7, self.a1],
+ )
+
+ def test_in_empty_list(self):
+ self.assertSequenceEqual(Article.objects.filter(id__in=[]), [])
+
+ def test_in_different_database(self):
+ with self.assertRaisesMessage(
+ ValueError,
+ "Subqueries aren't allowed across different databases. Force the "
+ "inner query to be evaluated using `list(inner_query)`.",
+ ):
+ list(Article.objects.filter(id__in=Article.objects.using("other").all()))
+
+ def test_in_keeps_value_ordering(self):
+ query = (
+ Article.objects.filter(slug__in=["a%d" % i for i in range(1, 8)])
+ .values("pk")
+ .query
+ )
+ self.assertIn(" IN (a1, a2, a3, a4, a5, a6, a7) ", str(query))
+
+ def test_in_ignore_none(self):
+ with self.assertNumQueries(1) as ctx:
+ self.assertSequenceEqual(
+ Article.objects.filter(id__in=[None, self.a1.id]),
+ [self.a1],
+ )
+ sql = ctx.captured_queries[0]["sql"]
+ self.assertIn("IN (%s)" % self.a1.pk, sql)
+
+ def test_in_ignore_solo_none(self):
+ with self.assertNumQueries(0):
+ self.assertSequenceEqual(Article.objects.filter(id__in=[None]), [])
+
+ def test_in_ignore_none_with_unhashable_items(self):
+ class UnhashableInt(int):
+ __hash__ = None
+
+ with self.assertNumQueries(1) as ctx:
+ self.assertSequenceEqual(
+ Article.objects.filter(id__in=[None, UnhashableInt(self.a1.id)]),
+ [self.a1],
+ )
+ sql = ctx.captured_queries[0]["sql"]
+ self.assertIn("IN (%s)" % self.a1.pk, sql)
+
+ def test_error_messages(self):
+ # Programming errors are pointed out with nice error messages
+ with self.assertRaisesMessage(
+ FieldError,
+ "Cannot resolve keyword 'pub_date_year' into field. Choices are: "
+ "author, author_id, headline, id, pub_date, slug, tag",
+ ):
+ Article.objects.filter(pub_date_year="2005").count()
+
+ def test_unsupported_lookups(self):
+ with self.assertRaisesMessage(
+ FieldError,
+ "Unsupported lookup 'starts' for CharField or join on the field "
+ "not permitted, perhaps you meant startswith or istartswith?",
+ ):
+ Article.objects.filter(headline__starts="Article")
+
+ with self.assertRaisesMessage(
+ FieldError,
+ "Unsupported lookup 'is_null' for DateTimeField or join on the field "
+ "not permitted, perhaps you meant isnull?",
+ ):
+ Article.objects.filter(pub_date__is_null=True)
+
+ with self.assertRaisesMessage(
+ FieldError,
+ "Unsupported lookup 'gobbledygook' for DateTimeField or join on the field "
+ "not permitted.",
+ ):
+ Article.objects.filter(pub_date__gobbledygook="blahblah")
+
+ def test_unsupported_lookups_custom_lookups(self):
+ slug_field = Article._meta.get_field("slug")
+ msg = (
+ "Unsupported lookup 'lengtp' for SlugField or join on the field not "
+ "permitted, perhaps you meant length?"
+ )
+ with self.assertRaisesMessage(FieldError, msg):
+ with register_lookup(slug_field, Length):
+ Article.objects.filter(slug__lengtp=20)
+
+ def test_relation_nested_lookup_error(self):
+ # An invalid nested lookup on a related field raises a useful error.
+ msg = (
+ "Unsupported lookup 'editor' for ForeignKey or join on the field not "
+ "permitted."
+ )
+ with self.assertRaisesMessage(FieldError, msg):
+ Article.objects.filter(author__editor__name="James")
+ msg = (
+ "Unsupported lookup 'foo' for ForeignKey or join on the field not "
+ "permitted."
+ )
+ with self.assertRaisesMessage(FieldError, msg):
+ Tag.objects.filter(articles__foo="bar")
+
+ def test_unsupported_lookup_reverse_foreign_key(self):
+ msg = (
+ "Unsupported lookup 'title' for ManyToOneRel or join on the field not "
+ "permitted."
+ )
+ with self.assertRaisesMessage(FieldError, msg):
+ Author.objects.filter(article__title="Article 1")
+
+ def test_unsupported_lookup_reverse_foreign_key_custom_lookups(self):
+ msg = (
+ "Unsupported lookup 'abspl' for ManyToOneRel or join on the field not "
+ "permitted, perhaps you meant abspk?"
+ )
+ fk_field = Article._meta.get_field("author")
+ with self.assertRaisesMessage(FieldError, msg):
+ with register_lookup(fk_field, Abs, lookup_name="abspk"):
+ Author.objects.filter(article__abspl=2)
+
+ def test_filter_by_reverse_related_field_transform(self):
+ fk_field = Article._meta.get_field("author")
+ with register_lookup(fk_field, Abs):
+ self.assertSequenceEqual(
+ Author.objects.filter(article__abs=self.a1.pk), [self.au1]
+ )
+
+ def test_regex(self):
+ # Create some articles with a bit more interesting headlines for
+ # testing field lookups.
+ Article.objects.all().delete()
+ now = datetime.now()
+ Article.objects.bulk_create(
+ [
+ Article(pub_date=now, headline="f"),
+ Article(pub_date=now, headline="fo"),
+ Article(pub_date=now, headline="foo"),
+ Article(pub_date=now, headline="fooo"),
+ Article(pub_date=now, headline="hey-Foo"),
+ Article(pub_date=now, headline="bar"),
+ Article(pub_date=now, headline="AbBa"),
+ Article(pub_date=now, headline="baz"),
+ Article(pub_date=now, headline="baxZ"),
+ ]
+ )
+ # zero-or-more
+ self.assertQuerySetEqual(
+ Article.objects.filter(headline__regex=r"fo*"),
+ Article.objects.filter(headline__in=["f", "fo", "foo", "fooo"]),
+ )
+ self.assertQuerySetEqual(
+ Article.objects.filter(headline__iregex=r"fo*"),
+ Article.objects.filter(headline__in=["f", "fo", "foo", "fooo", "hey-Foo"]),
+ )
+ # one-or-more
+ self.assertQuerySetEqual(
+ Article.objects.filter(headline__regex=r"fo+"),
+ Article.objects.filter(headline__in=["fo", "foo", "fooo"]),
+ )
+ # wildcard
+ self.assertQuerySetEqual(
+ Article.objects.filter(headline__regex=r"fooo?"),
+ Article.objects.filter(headline__in=["foo", "fooo"]),
+ )
+ # leading anchor
+ self.assertQuerySetEqual(
+ Article.objects.filter(headline__regex=r"^b"),
+ Article.objects.filter(headline__in=["bar", "baxZ", "baz"]),
+ )
+ self.assertQuerySetEqual(
+ Article.objects.filter(headline__iregex=r"^a"),
+ Article.objects.filter(headline="AbBa"),
+ )
+ # trailing anchor
+ self.assertQuerySetEqual(
+ Article.objects.filter(headline__regex=r"z$"),
+ Article.objects.filter(headline="baz"),
+ )
+ self.assertQuerySetEqual(
+ Article.objects.filter(headline__iregex=r"z$"),
+ Article.objects.filter(headline__in=["baxZ", "baz"]),
+ )
+ # character sets
+ self.assertQuerySetEqual(
+ Article.objects.filter(headline__regex=r"ba[rz]"),
+ Article.objects.filter(headline__in=["bar", "baz"]),
+ )
+ self.assertQuerySetEqual(
+ Article.objects.filter(headline__regex=r"ba.[RxZ]"),
+ Article.objects.filter(headline="baxZ"),
+ )
+ self.assertQuerySetEqual(
+ Article.objects.filter(headline__iregex=r"ba[RxZ]"),
+ Article.objects.filter(headline__in=["bar", "baxZ", "baz"]),
+ )
+
+ # and more articles:
+ Article.objects.bulk_create(
+ [
+ Article(pub_date=now, headline="foobar"),
+ Article(pub_date=now, headline="foobaz"),
+ Article(pub_date=now, headline="ooF"),
+ Article(pub_date=now, headline="foobarbaz"),
+ Article(pub_date=now, headline="zoocarfaz"),
+ Article(pub_date=now, headline="barfoobaz"),
+ Article(pub_date=now, headline="bazbaRFOO"),
+ ]
+ )
+
+ # alternation
+ self.assertQuerySetEqual(
+ Article.objects.filter(headline__regex=r"oo(f|b)"),
+ Article.objects.filter(
+ headline__in=[
+ "barfoobaz",
+ "foobar",
+ "foobarbaz",
+ "foobaz",
+ ]
+ ),
+ )
+ self.assertQuerySetEqual(
+ Article.objects.filter(headline__iregex=r"oo(f|b)"),
+ Article.objects.filter(
+ headline__in=[
+ "barfoobaz",
+ "foobar",
+ "foobarbaz",
+ "foobaz",
+ "ooF",
+ ]
+ ),
+ )
+ self.assertQuerySetEqual(
+ Article.objects.filter(headline__regex=r"^foo(f|b)"),
+ Article.objects.filter(headline__in=["foobar", "foobarbaz", "foobaz"]),
+ )
+
+ # greedy matching
+ self.assertQuerySetEqual(
+ Article.objects.filter(headline__regex=r"b.*az"),
+ Article.objects.filter(
+ headline__in=[
+ "barfoobaz",
+ "baz",
+ "bazbaRFOO",
+ "foobarbaz",
+ "foobaz",
+ ]
+ ),
+ )
+ self.assertQuerySetEqual(
+ Article.objects.filter(headline__iregex=r"b.*ar"),
+ Article.objects.filter(
+ headline__in=[
+ "bar",
+ "barfoobaz",
+ "bazbaRFOO",
+ "foobar",
+ "foobarbaz",
+ ]
+ ),
+ )
+
+ @skipUnlessDBFeature("supports_regex_backreferencing")
+ def test_regex_backreferencing(self):
+ # grouping and backreferences
+ now = datetime.now()
+ Article.objects.bulk_create(
+ [
+ Article(pub_date=now, headline="foobar"),
+ Article(pub_date=now, headline="foobaz"),
+ Article(pub_date=now, headline="ooF"),
+ Article(pub_date=now, headline="foobarbaz"),
+ Article(pub_date=now, headline="zoocarfaz"),
+ Article(pub_date=now, headline="barfoobaz"),
+ Article(pub_date=now, headline="bazbaRFOO"),
+ ]
+ )
+ self.assertQuerySetEqual(
+ Article.objects.filter(headline__regex=r"b(.).*b\1").values_list(
+ "headline", flat=True
+ ),
+ ["barfoobaz", "bazbaRFOO", "foobarbaz"],
+ )
+
+ def test_regex_null(self):
+ """
+ A regex lookup does not fail on null/None values
+ """
+ Season.objects.create(year=2012, gt=None)
+ self.assertQuerySetEqual(Season.objects.filter(gt__regex=r"^$"), [])
+
+ def test_textfield_exact_null(self):
+ with self.assertNumQueries(1) as ctx:
+ self.assertSequenceEqual(Author.objects.filter(bio=None), [self.au2])
+ # Columns with IS NULL condition are not wrapped (except PostgreSQL).
+ bio_column = connection.ops.quote_name(Author._meta.get_field("bio").column)
+ self.assertIn(f"{bio_column} IS NULL", ctx.captured_queries[0]["sql"])
+
+ def test_regex_non_string(self):
+ """
+ A regex lookup does not fail on non-string fields
+ """
+ s = Season.objects.create(year=2013, gt=444)
+ self.assertQuerySetEqual(Season.objects.filter(gt__regex=r"^444$"), [s])
+
+ def test_regex_non_ascii(self):
+ """
+ A regex lookup does not trip on non-ASCII characters.
+ """
+ Player.objects.create(name="\u2660")
+ Player.objects.get(name__regex="\u2660")
+
+ def test_nonfield_lookups(self):
+ """
+ A lookup query containing non-fields raises the proper exception.
+ """
+ msg = (
+ "Unsupported lookup 'blahblah' for CharField or join on the field not "
+ "permitted."
+ )
+ with self.assertRaisesMessage(FieldError, msg):
+ Article.objects.filter(headline__blahblah=99)
+ with self.assertRaisesMessage(FieldError, msg):
+ Article.objects.filter(headline__blahblah__exact=99)
+ msg = (
+ "Cannot resolve keyword 'blahblah' into field. Choices are: "
+ "author, author_id, headline, id, pub_date, slug, tag"
+ )
+ with self.assertRaisesMessage(FieldError, msg):
+ Article.objects.filter(blahblah=99)
+
+ def test_lookup_collision(self):
+ """
+ Genuine field names don't collide with built-in lookup types
+ ('year', 'gt', 'range', 'in' etc.) (#11670).
+ """
+ # 'gt' is used as a code number for the year, e.g. 111=>2009.
+ season_2009 = Season.objects.create(year=2009, gt=111)
+ season_2009.games.create(home="Houston Astros", away="St. Louis Cardinals")
+ season_2010 = Season.objects.create(year=2010, gt=222)
+ season_2010.games.create(home="Houston Astros", away="Chicago Cubs")
+ season_2010.games.create(home="Houston Astros", away="Milwaukee Brewers")
+ season_2010.games.create(home="Houston Astros", away="St. Louis Cardinals")
+ season_2011 = Season.objects.create(year=2011, gt=333)
+ season_2011.games.create(home="Houston Astros", away="St. Louis Cardinals")
+ season_2011.games.create(home="Houston Astros", away="Milwaukee Brewers")
+ hunter_pence = Player.objects.create(name="Hunter Pence")
+ hunter_pence.games.set(Game.objects.filter(season__year__in=[2009, 2010]))
+ pudge = Player.objects.create(name="Ivan Rodriquez")
+ pudge.games.set(Game.objects.filter(season__year=2009))
+ pedro_feliz = Player.objects.create(name="Pedro Feliz")
+ pedro_feliz.games.set(Game.objects.filter(season__year__in=[2011]))
+ johnson = Player.objects.create(name="Johnson")
+ johnson.games.set(Game.objects.filter(season__year__in=[2011]))
+
+ # Games in 2010
+ self.assertEqual(Game.objects.filter(season__year=2010).count(), 3)
+ self.assertEqual(Game.objects.filter(season__year__exact=2010).count(), 3)
+ self.assertEqual(Game.objects.filter(season__gt=222).count(), 3)
+ self.assertEqual(Game.objects.filter(season__gt__exact=222).count(), 3)
+
+ # Games in 2011
+ self.assertEqual(Game.objects.filter(season__year=2011).count(), 2)
+ self.assertEqual(Game.objects.filter(season__year__exact=2011).count(), 2)
+ self.assertEqual(Game.objects.filter(season__gt=333).count(), 2)
+ self.assertEqual(Game.objects.filter(season__gt__exact=333).count(), 2)
+ self.assertEqual(Game.objects.filter(season__year__gt=2010).count(), 2)
+ self.assertEqual(Game.objects.filter(season__gt__gt=222).count(), 2)
+
+ # Games played in 2010 and 2011
+ self.assertEqual(Game.objects.filter(season__year__in=[2010, 2011]).count(), 5)
+ self.assertEqual(Game.objects.filter(season__year__gt=2009).count(), 5)
+ self.assertEqual(Game.objects.filter(season__gt__in=[222, 333]).count(), 5)
+ self.assertEqual(Game.objects.filter(season__gt__gt=111).count(), 5)
+
+ # Players who played in 2009
+ self.assertEqual(
+ Player.objects.filter(games__season__year=2009).distinct().count(), 2
+ )
+ self.assertEqual(
+ Player.objects.filter(games__season__year__exact=2009).distinct().count(), 2
+ )
+ self.assertEqual(
+ Player.objects.filter(games__season__gt=111).distinct().count(), 2
+ )
+ self.assertEqual(
+ Player.objects.filter(games__season__gt__exact=111).distinct().count(), 2
+ )
+
+ # Players who played in 2010
+ self.assertEqual(
+ Player.objects.filter(games__season__year=2010).distinct().count(), 1
+ )
+ self.assertEqual(
+ Player.objects.filter(games__season__year__exact=2010).distinct().count(), 1
+ )
+ self.assertEqual(
+ Player.objects.filter(games__season__gt=222).distinct().count(), 1
+ )
+ self.assertEqual(
+ Player.objects.filter(games__season__gt__exact=222).distinct().count(), 1
+ )
+
+ # Players who played in 2011
+ self.assertEqual(
+ Player.objects.filter(games__season__year=2011).distinct().count(), 2
+ )
+ self.assertEqual(
+ Player.objects.filter(games__season__year__exact=2011).distinct().count(), 2
+ )
+ self.assertEqual(
+ Player.objects.filter(games__season__gt=333).distinct().count(), 2
+ )
+ self.assertEqual(
+ Player.objects.filter(games__season__year__gt=2010).distinct().count(), 2
+ )
+ self.assertEqual(
+ Player.objects.filter(games__season__gt__gt=222).distinct().count(), 2
+ )
+
+ def test_chain_date_time_lookups(self):
+ self.assertCountEqual(
+ Article.objects.filter(pub_date__month__gt=7),
+ [self.a5, self.a6],
+ )
+ self.assertCountEqual(
+ Article.objects.filter(pub_date__day__gte=27),
+ [self.a2, self.a3, self.a4, self.a7],
+ )
+ self.assertCountEqual(
+ Article.objects.filter(pub_date__hour__lt=8),
+ [self.a1, self.a2, self.a3, self.a4, self.a7],
+ )
+ self.assertCountEqual(
+ Article.objects.filter(pub_date__minute__lte=0),
+ [self.a1, self.a2, self.a3, self.a4, self.a5, self.a6, self.a7],
+ )
+
+ def test_exact_none_transform(self):
+ """Transforms are used for __exact=None."""
+ Season.objects.create(year=1, nulled_text_field="not null")
+ self.assertFalse(Season.objects.filter(nulled_text_field__isnull=True))
+ self.assertTrue(Season.objects.filter(nulled_text_field__nulled__isnull=True))
+ self.assertTrue(Season.objects.filter(nulled_text_field__nulled__exact=None))
+ self.assertTrue(Season.objects.filter(nulled_text_field__nulled=None))
+
+ def test_exact_sliced_queryset_limit_one(self):
+ self.assertCountEqual(
+ Article.objects.filter(author=Author.objects.all()[:1]),
+ [self.a1, self.a2, self.a3, self.a4],
+ )
+
+ def test_exact_sliced_queryset_limit_one_offset(self):
+ self.assertCountEqual(
+ Article.objects.filter(author=Author.objects.all()[1:2]),
+ [self.a5, self.a6, self.a7],
+ )
+
+ def test_exact_sliced_queryset_not_limited_to_one(self):
+ msg = (
+ "The QuerySet value for an exact lookup must be limited to one "
+ "result using slicing."
+ )
+ with self.assertRaisesMessage(ValueError, msg):
+ list(Article.objects.filter(author=Author.objects.all()[:2]))
+ with self.assertRaisesMessage(ValueError, msg):
+ list(Article.objects.filter(author=Author.objects.all()[1:]))
+
+ @skipUnless(connection.vendor == "mysql", "MySQL-specific workaround.")
+ def test_exact_booleanfield(self):
+ # MySQL ignores indexes with boolean fields unless they're compared
+ # directly to a boolean value.
+ product = Product.objects.create(name="Paper", qty_target=5000)
+ Stock.objects.create(product=product, short=False, qty_available=5100)
+ stock_1 = Stock.objects.create(product=product, short=True, qty_available=180)
+ qs = Stock.objects.filter(short=True)
+ self.assertSequenceEqual(qs, [stock_1])
+ self.assertIn(
+ "%s = True" % connection.ops.quote_name("short"),
+ str(qs.query),
+ )
+
+ @skipUnless(connection.vendor == "mysql", "MySQL-specific workaround.")
+ def test_exact_booleanfield_annotation(self):
+ # MySQL ignores indexes with boolean fields unless they're compared
+ # directly to a boolean value.
+ qs = Author.objects.annotate(
+ case=Case(
+ When(alias="a1", then=True),
+ default=False,
+ output_field=BooleanField(),
+ )
+ ).filter(case=True)
+ self.assertSequenceEqual(qs, [self.au1])
+ self.assertIn(" = True", str(qs.query))
+
+ qs = Author.objects.annotate(
+ wrapped=ExpressionWrapper(Q(alias="a1"), output_field=BooleanField()),
+ ).filter(wrapped=True)
+ self.assertSequenceEqual(qs, [self.au1])
+ self.assertIn(" = True", str(qs.query))
+ # EXISTS(...) shouldn't be compared to a boolean value.
+ qs = Author.objects.annotate(
+ exists=Exists(Author.objects.filter(alias="a1", pk=OuterRef("pk"))),
+ ).filter(exists=True)
+ self.assertSequenceEqual(qs, [self.au1])
+ self.assertNotIn(" = True", str(qs.query))
+
+ def test_custom_field_none_rhs(self):
+ """
+ __exact=value is transformed to __isnull=True if Field.get_prep_value()
+ converts value to None.
+ """
+ season = Season.objects.create(year=2012, nulled_text_field=None)
+ self.assertTrue(
+ Season.objects.filter(pk=season.pk, nulled_text_field__isnull=True)
+ )
+ self.assertTrue(Season.objects.filter(pk=season.pk, nulled_text_field=""))
+
+ def test_pattern_lookups_with_substr(self):
+ a = Author.objects.create(name="John Smith", alias="Johx")
+ b = Author.objects.create(name="Rhonda Simpson", alias="sonx")
+ tests = (
+ ("startswith", [a]),
+ ("istartswith", [a]),
+ ("contains", [a, b]),
+ ("icontains", [a, b]),
+ ("endswith", [b]),
+ ("iendswith", [b]),
+ )
+ for lookup, result in tests:
+ with self.subTest(lookup=lookup):
+ authors = Author.objects.filter(
+ **{"name__%s" % lookup: Substr("alias", 1, 3)}
+ )
+ self.assertCountEqual(authors, result)
+
+ def test_custom_lookup_none_rhs(self):
+ """Lookup.can_use_none_as_rhs=True allows None as a lookup value."""
+ season = Season.objects.create(year=2012, nulled_text_field=None)
+ query = Season.objects.get_queryset().query
+ field = query.model._meta.get_field("nulled_text_field")
+ self.assertIsInstance(
+ query.build_lookup(["isnull_none_rhs"], field, None), IsNullWithNoneAsRHS
+ )
+ self.assertTrue(
+ Season.objects.filter(pk=season.pk, nulled_text_field__isnull_none_rhs=True)
+ )
+
+ def test_exact_exists(self):
+ qs = Article.objects.filter(pk=OuterRef("pk"))
+ seasons = Season.objects.annotate(pk_exists=Exists(qs)).filter(
+ pk_exists=Exists(qs),
+ )
+ self.assertCountEqual(seasons, Season.objects.all())
+
+ def test_nested_outerref_lhs(self):
+ tag = Tag.objects.create(name=self.au1.alias)
+ tag.articles.add(self.a1)
+ qs = Tag.objects.annotate(
+ has_author_alias_match=Exists(
+ Article.objects.annotate(
+ author_exists=Exists(
+ Author.objects.filter(alias=OuterRef(OuterRef("name")))
+ ),
+ ).filter(author_exists=True)
+ ),
+ )
+ self.assertEqual(qs.get(has_author_alias_match=True), tag)
+
+ def test_exact_query_rhs_with_selected_columns(self):
+ newest_author = Author.objects.create(name="Author 2")
+ authors_max_ids = (
+ Author.objects.filter(
+ name="Author 2",
+ )
+ .values(
+ "name",
+ )
+ .annotate(
+ max_id=Max("id"),
+ )
+ .values("max_id")
+ )
+ authors = Author.objects.filter(id=authors_max_ids[:1])
+ self.assertEqual(authors.get(), newest_author)
+
+ def test_isnull_non_boolean_value(self):
+ msg = "The QuerySet value for an isnull lookup must be True or False."
+ tests = [
+ Author.objects.filter(alias__isnull=1),
+ Article.objects.filter(author__isnull=1),
+ Season.objects.filter(games__isnull=1),
+ Freebie.objects.filter(stock__isnull=1),
+ ]
+ for qs in tests:
+ with self.subTest(qs=qs):
+ with self.assertRaisesMessage(ValueError, msg):
+ qs.exists()
+
+ def test_lookup_rhs(self):
+ product = Product.objects.create(name="GME", qty_target=5000)
+ stock_1 = Stock.objects.create(product=product, short=True, qty_available=180)
+ stock_2 = Stock.objects.create(product=product, short=False, qty_available=5100)
+ Stock.objects.create(product=product, short=False, qty_available=4000)
+ self.assertCountEqual(
+ Stock.objects.filter(short=Q(qty_available__lt=F("product__qty_target"))),
+ [stock_1, stock_2],
+ )
+ self.assertCountEqual(
+ Stock.objects.filter(
+ short=ExpressionWrapper(
+ Q(qty_available__lt=F("product__qty_target")),
+ output_field=BooleanField(),
+ )
+ ),
+ [stock_1, stock_2],
+ )
+
+
+class LookupQueryingTests(TestCase):
+ @classmethod
+ def setUpTestData(cls):
+ cls.s1 = Season.objects.create(year=1942, gt=1942)
+ cls.s2 = Season.objects.create(year=1842, gt=1942, nulled_text_field="text")
+ cls.s3 = Season.objects.create(year=2042, gt=1942)
+ Game.objects.create(season=cls.s1, home="NY", away="Boston")
+ Game.objects.create(season=cls.s1, home="NY", away="Tampa")
+ Game.objects.create(season=cls.s3, home="Boston", away="Tampa")
+
+ def test_annotate(self):
+ qs = Season.objects.annotate(equal=Exact(F("year"), 1942))
+ self.assertCountEqual(
+ qs.values_list("year", "equal"),
+ ((1942, True), (1842, False), (2042, False)),
+ )
+
+ def test_alias(self):
+ qs = Season.objects.alias(greater=GreaterThan(F("year"), 1910))
+ self.assertCountEqual(qs.filter(greater=True), [self.s1, self.s3])
+
+ def test_annotate_value_greater_than_value(self):
+ qs = Season.objects.annotate(greater=GreaterThan(Value(40), Value(30)))
+ self.assertCountEqual(
+ qs.values_list("year", "greater"),
+ ((1942, True), (1842, True), (2042, True)),
+ )
+
+ def test_annotate_field_greater_than_field(self):
+ qs = Season.objects.annotate(greater=GreaterThan(F("year"), F("gt")))
+ self.assertCountEqual(
+ qs.values_list("year", "greater"),
+ ((1942, False), (1842, False), (2042, True)),
+ )
+
+ def test_annotate_field_greater_than_value(self):
+ qs = Season.objects.annotate(greater=GreaterThan(F("year"), Value(1930)))
+ self.assertCountEqual(
+ qs.values_list("year", "greater"),
+ ((1942, True), (1842, False), (2042, True)),
+ )
+
+ def test_annotate_field_greater_than_literal(self):
+ qs = Season.objects.annotate(greater=GreaterThan(F("year"), 1930))
+ self.assertCountEqual(
+ qs.values_list("year", "greater"),
+ ((1942, True), (1842, False), (2042, True)),
+ )
+
+ def test_annotate_literal_greater_than_field(self):
+ qs = Season.objects.annotate(greater=GreaterThan(1930, F("year")))
+ self.assertCountEqual(
+ qs.values_list("year", "greater"),
+ ((1942, False), (1842, True), (2042, False)),
+ )
+
+ def test_annotate_less_than_float(self):
+ qs = Season.objects.annotate(lesser=LessThan(F("year"), 1942.1))
+ self.assertCountEqual(
+ qs.values_list("year", "lesser"),
+ ((1942, True), (1842, True), (2042, False)),
+ )
+
+ def test_annotate_greater_than_or_equal(self):
+ qs = Season.objects.annotate(greater=GreaterThanOrEqual(F("year"), 1942))
+ self.assertCountEqual(
+ qs.values_list("year", "greater"),
+ ((1942, True), (1842, False), (2042, True)),
+ )
+
+ def test_annotate_greater_than_or_equal_float(self):
+ qs = Season.objects.annotate(greater=GreaterThanOrEqual(F("year"), 1942.1))
+ self.assertCountEqual(
+ qs.values_list("year", "greater"),
+ ((1942, False), (1842, False), (2042, True)),
+ )
+
+ def test_combined_lookups(self):
+ expression = Exact(F("year"), 1942) | GreaterThan(F("year"), 1942)
+ qs = Season.objects.annotate(gte=expression)
+ self.assertCountEqual(
+ qs.values_list("year", "gte"),
+ ((1942, True), (1842, False), (2042, True)),
+ )
+
+ def test_lookup_in_filter(self):
+ qs = Season.objects.filter(GreaterThan(F("year"), 1910))
+ self.assertCountEqual(qs, [self.s1, self.s3])
+
+ def test_isnull_lookup_in_filter(self):
+ self.assertSequenceEqual(
+ Season.objects.filter(IsNull(F("nulled_text_field"), False)),
+ [self.s2],
+ )
+ self.assertCountEqual(
+ Season.objects.filter(IsNull(F("nulled_text_field"), True)),
+ [self.s1, self.s3],
+ )
+
+ def test_filter_lookup_lhs(self):
+ qs = Season.objects.annotate(before_20=LessThan(F("year"), 2000)).filter(
+ before_20=LessThan(F("year"), 1900),
+ )
+ self.assertCountEqual(qs, [self.s2, self.s3])
+
+ def test_filter_wrapped_lookup_lhs(self):
+ qs = (
+ Season.objects.annotate(
+ before_20=ExpressionWrapper(
+ Q(year__lt=2000),
+ output_field=BooleanField(),
+ )
+ )
+ .filter(before_20=LessThan(F("year"), 1900))
+ .values_list("year", flat=True)
+ )
+ self.assertCountEqual(qs, [1842, 2042])
+
+ def test_filter_exists_lhs(self):
+ qs = Season.objects.annotate(
+ before_20=Exists(
+ Season.objects.filter(pk=OuterRef("pk"), year__lt=2000),
+ )
+ ).filter(before_20=LessThan(F("year"), 1900))
+ self.assertCountEqual(qs, [self.s2, self.s3])
+
+ def test_filter_subquery_lhs(self):
+ qs = Season.objects.annotate(
+ before_20=Subquery(
+ Season.objects.filter(pk=OuterRef("pk")).values(
+ lesser=LessThan(F("year"), 2000),
+ ),
+ )
+ ).filter(before_20=LessThan(F("year"), 1900))
+ self.assertCountEqual(qs, [self.s2, self.s3])
+
+ def test_combined_lookups_in_filter(self):
+ expression = Exact(F("year"), 1942) | GreaterThan(F("year"), 1942)
+ qs = Season.objects.filter(expression)
+ self.assertCountEqual(qs, [self.s1, self.s3])
+
+ def test_combined_annotated_lookups_in_filter(self):
+ expression = Exact(F("year"), 1942) | GreaterThan(F("year"), 1942)
+ qs = Season.objects.annotate(gte=expression).filter(gte=True)
+ self.assertCountEqual(qs, [self.s1, self.s3])
+
+ def test_combined_annotated_lookups_in_filter_false(self):
+ expression = Exact(F("year"), 1942) | GreaterThan(F("year"), 1942)
+ qs = Season.objects.annotate(gte=expression).filter(gte=False)
+ self.assertSequenceEqual(qs, [self.s2])
+
+ def test_lookup_in_order_by(self):
+ qs = Season.objects.order_by(LessThan(F("year"), 1910), F("year"))
+ self.assertSequenceEqual(qs, [self.s1, self.s3, self.s2])
+
+ @skipUnlessDBFeature("supports_boolean_expr_in_select_clause")
+ def test_aggregate_combined_lookup(self):
+ expression = Cast(GreaterThan(F("year"), 1900), models.IntegerField())
+ qs = Season.objects.aggregate(modern=models.Sum(expression))
+ self.assertEqual(qs["modern"], 2)
+
+ def test_conditional_expression(self):
+ qs = Season.objects.annotate(
+ century=Case(
+ When(
+ GreaterThan(F("year"), 1900) & LessThanOrEqual(F("year"), 2000),
+ then=Value("20th"),
+ ),
+ default=Value("other"),
+ )
+ ).values("year", "century")
+ self.assertCountEqual(
+ qs,
+ [
+ {"year": 1942, "century": "20th"},
+ {"year": 1842, "century": "other"},
+ {"year": 2042, "century": "other"},
+ ],
+ )
+
+ def test_multivalued_join_reuse(self):
+ self.assertEqual(
+ Season.objects.get(Exact(F("games__home"), "NY"), games__away="Boston"),
+ self.s1,
+ )
+ self.assertEqual(
+ Season.objects.get(Exact(F("games__home"), "NY") & Q(games__away="Boston")),
+ self.s1,
+ )
+ self.assertEqual(
+ Season.objects.get(
+ Exact(F("games__home"), "NY") & Exact(F("games__away"), "Boston")
+ ),
+ self.s1,
+ )
diff --git a/testbed/django__django/tests/m2m_and_m2o/__init__.py b/testbed/django__django/tests/m2m_and_m2o/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testbed/django__django/tests/m2m_and_m2o/models.py b/testbed/django__django/tests/m2m_and_m2o/models.py
new file mode 100644
index 0000000000000000000000000000000000000000..6a5b0b29c984d884d3bb0183c48c610aad837434
--- /dev/null
+++ b/testbed/django__django/tests/m2m_and_m2o/models.py
@@ -0,0 +1,26 @@
+"""
+Many-to-many and many-to-one relationships to the same table
+
+Make sure to set ``related_name`` if you use relationships to the same table.
+"""
+from django.db import models
+
+
+class User(models.Model):
+ username = models.CharField(max_length=20)
+
+
+class Issue(models.Model):
+ num = models.IntegerField()
+ cc = models.ManyToManyField(User, blank=True, related_name="test_issue_cc")
+ client = models.ForeignKey(User, models.CASCADE, related_name="test_issue_client")
+
+ class Meta:
+ ordering = ("num",)
+
+ def __str__(self):
+ return str(self.num)
+
+
+class StringReferenceModel(models.Model):
+ others = models.ManyToManyField("StringReferenceModel")
diff --git a/testbed/django__django/tests/m2m_and_m2o/tests.py b/testbed/django__django/tests/m2m_and_m2o/tests.py
new file mode 100644
index 0000000000000000000000000000000000000000..2ca945816cf281fde5e08b749ab56edfa685b74d
--- /dev/null
+++ b/testbed/django__django/tests/m2m_and_m2o/tests.py
@@ -0,0 +1,98 @@
+from django.db.models import Q
+from django.test import TestCase
+
+from .models import Issue, StringReferenceModel, User
+
+
+class RelatedObjectTests(TestCase):
+ def test_related_objects_have_name_attribute(self):
+ for field_name in ("test_issue_client", "test_issue_cc"):
+ obj = User._meta.get_field(field_name)
+ self.assertEqual(field_name, obj.field.related_query_name())
+
+ def test_m2m_and_m2o(self):
+ r = User.objects.create(username="russell")
+ g = User.objects.create(username="gustav")
+
+ i1 = Issue(num=1)
+ i1.client = r
+ i1.save()
+
+ i2 = Issue(num=2)
+ i2.client = r
+ i2.save()
+ i2.cc.add(r)
+
+ i3 = Issue(num=3)
+ i3.client = g
+ i3.save()
+ i3.cc.add(r)
+
+ self.assertQuerySetEqual(
+ Issue.objects.filter(client=r.id),
+ [
+ 1,
+ 2,
+ ],
+ lambda i: i.num,
+ )
+ self.assertQuerySetEqual(
+ Issue.objects.filter(client=g.id),
+ [
+ 3,
+ ],
+ lambda i: i.num,
+ )
+ self.assertQuerySetEqual(Issue.objects.filter(cc__id__exact=g.id), [])
+ self.assertQuerySetEqual(
+ Issue.objects.filter(cc__id__exact=r.id),
+ [
+ 2,
+ 3,
+ ],
+ lambda i: i.num,
+ )
+
+ # These queries combine results from the m2m and the m2o relationships.
+ # They're three ways of saying the same thing.
+ self.assertQuerySetEqual(
+ Issue.objects.filter(Q(cc__id__exact=r.id) | Q(client=r.id)),
+ [
+ 1,
+ 2,
+ 3,
+ ],
+ lambda i: i.num,
+ )
+ self.assertQuerySetEqual(
+ Issue.objects.filter(cc__id__exact=r.id)
+ | Issue.objects.filter(client=r.id),
+ [
+ 1,
+ 2,
+ 3,
+ ],
+ lambda i: i.num,
+ )
+ self.assertQuerySetEqual(
+ Issue.objects.filter(Q(client=r.id) | Q(cc__id__exact=r.id)),
+ [
+ 1,
+ 2,
+ 3,
+ ],
+ lambda i: i.num,
+ )
+
+
+class RelatedObjectUnicodeTests(TestCase):
+ def test_m2m_with_unicode_reference(self):
+ """
+ Regression test for #6045: references to other models can be
+ strings, providing they are directly convertible to ASCII.
+ """
+ m1 = StringReferenceModel.objects.create()
+ m2 = StringReferenceModel.objects.create()
+ m2.others.add(m1) # used to cause an error (see ticket #6045)
+ m2.save()
+ list(m2.others.all()) # Force retrieval.
diff --git a/testbed/django__django/tests/m2m_intermediary/__init__.py b/testbed/django__django/tests/m2m_intermediary/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testbed/django__django/tests/m2m_intermediary/models.py b/testbed/django__django/tests/m2m_intermediary/models.py
new file mode 100644
index 0000000000000000000000000000000000000000..1333d14b410aba4506ffea5347418f926eddcf57
--- /dev/null
+++ b/testbed/django__django/tests/m2m_intermediary/models.py
@@ -0,0 +1,31 @@
+"""
+Many-to-many relationships via an intermediary table
+
+For many-to-many relationships that need extra fields on the intermediary
+table, use an intermediary model.
+
+In this example, an ``Article`` can have multiple ``Reporter`` objects, and
+each ``Article``-``Reporter`` combination (a ``Writer``) has a ``position``
+field, which specifies the ``Reporter``'s position for the given article
+(e.g. "Staff writer").
+"""
+from django.db import models
+
+
+class Reporter(models.Model):
+ first_name = models.CharField(max_length=30)
+ last_name = models.CharField(max_length=30)
+
+ 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()
+
+
+class Writer(models.Model):
+ reporter = models.ForeignKey(Reporter, models.CASCADE)
+ article = models.ForeignKey(Article, models.CASCADE)
+ position = models.CharField(max_length=100)
diff --git a/testbed/django__django/tests/m2m_intermediary/tests.py b/testbed/django__django/tests/m2m_intermediary/tests.py
new file mode 100644
index 0000000000000000000000000000000000000000..93abbde65ecfc689fdbcba34e9ee4fbe082b1d26
--- /dev/null
+++ b/testbed/django__django/tests/m2m_intermediary/tests.py
@@ -0,0 +1,38 @@
+from datetime import datetime
+
+from django.test import TestCase
+
+from .models import Article, Reporter, Writer
+
+
+class M2MIntermediaryTests(TestCase):
+ def test_intermediary(self):
+ r1 = Reporter.objects.create(first_name="John", last_name="Smith")
+ r2 = Reporter.objects.create(first_name="Jane", last_name="Doe")
+
+ a = Article.objects.create(
+ headline="This is a test", pub_date=datetime(2005, 7, 27)
+ )
+
+ w1 = Writer.objects.create(reporter=r1, article=a, position="Main writer")
+ w2 = Writer.objects.create(reporter=r2, article=a, position="Contributor")
+
+ self.assertQuerySetEqual(
+ a.writer_set.select_related().order_by("-position"),
+ [
+ ("John Smith", "Main writer"),
+ ("Jane Doe", "Contributor"),
+ ],
+ lambda w: (str(w.reporter), w.position),
+ )
+ self.assertEqual(w1.reporter, r1)
+ self.assertEqual(w2.reporter, r2)
+
+ self.assertEqual(w1.article, a)
+ self.assertEqual(w2.article, a)
+
+ self.assertQuerySetEqual(
+ r1.writer_set.all(),
+ [("John Smith", "Main writer")],
+ lambda w: (str(w.reporter), w.position),
+ )
diff --git a/testbed/django__django/tests/m2m_multiple/__init__.py b/testbed/django__django/tests/m2m_multiple/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testbed/django__django/tests/m2m_multiple/models.py b/testbed/django__django/tests/m2m_multiple/models.py
new file mode 100644
index 0000000000000000000000000000000000000000..2146a8920163a03946d739cec19f6a4e2e3f7680
--- /dev/null
+++ b/testbed/django__django/tests/m2m_multiple/models.py
@@ -0,0 +1,37 @@
+"""
+Multiple many-to-many relationships between the same two tables
+
+In this example, an ``Article`` can have many "primary" ``Category`` objects
+and many "secondary" ``Category`` objects.
+
+Set ``related_name`` to designate what the reverse relationship is called.
+"""
+
+from django.db import models
+
+
+class Category(models.Model):
+ name = models.CharField(max_length=20)
+
+ class Meta:
+ ordering = ("name",)
+
+ def __str__(self):
+ return self.name
+
+
+class Article(models.Model):
+ headline = models.CharField(max_length=50)
+ pub_date = models.DateTimeField()
+ primary_categories = models.ManyToManyField(
+ Category, related_name="primary_article_set"
+ )
+ secondary_categories = models.ManyToManyField(
+ Category, related_name="secondary_article_set"
+ )
+
+ class Meta:
+ ordering = ("pub_date",)
+
+ def __str__(self):
+ return self.headline
diff --git a/testbed/django__django/tests/m2m_multiple/tests.py b/testbed/django__django/tests/m2m_multiple/tests.py
new file mode 100644
index 0000000000000000000000000000000000000000..52acc906372f3f9147119d3752af7732c550ac7a
--- /dev/null
+++ b/testbed/django__django/tests/m2m_multiple/tests.py
@@ -0,0 +1,83 @@
+from datetime import datetime
+
+from django.test import TestCase
+
+from .models import Article, Category
+
+
+class M2MMultipleTests(TestCase):
+ def test_multiple(self):
+ c1, c2, c3, c4 = [
+ Category.objects.create(name=name)
+ for name in ["Sports", "News", "Crime", "Life"]
+ ]
+
+ a1 = Article.objects.create(
+ headline="Parrot steals", pub_date=datetime(2005, 11, 27)
+ )
+ a1.primary_categories.add(c2, c3)
+ a1.secondary_categories.add(c4)
+
+ a2 = Article.objects.create(
+ headline="Parrot runs", pub_date=datetime(2005, 11, 28)
+ )
+ a2.primary_categories.add(c1, c2)
+ a2.secondary_categories.add(c4)
+
+ self.assertQuerySetEqual(
+ a1.primary_categories.all(),
+ [
+ "Crime",
+ "News",
+ ],
+ lambda c: c.name,
+ )
+ self.assertQuerySetEqual(
+ a2.primary_categories.all(),
+ [
+ "News",
+ "Sports",
+ ],
+ lambda c: c.name,
+ )
+ self.assertQuerySetEqual(
+ a1.secondary_categories.all(),
+ [
+ "Life",
+ ],
+ lambda c: c.name,
+ )
+ self.assertQuerySetEqual(
+ c1.primary_article_set.all(),
+ [
+ "Parrot runs",
+ ],
+ lambda a: a.headline,
+ )
+ self.assertQuerySetEqual(c1.secondary_article_set.all(), [])
+ self.assertQuerySetEqual(
+ c2.primary_article_set.all(),
+ [
+ "Parrot steals",
+ "Parrot runs",
+ ],
+ lambda a: a.headline,
+ )
+ self.assertQuerySetEqual(c2.secondary_article_set.all(), [])
+ self.assertQuerySetEqual(
+ c3.primary_article_set.all(),
+ [
+ "Parrot steals",
+ ],
+ lambda a: a.headline,
+ )
+ self.assertQuerySetEqual(c3.secondary_article_set.all(), [])
+ self.assertQuerySetEqual(c4.primary_article_set.all(), [])
+ self.assertQuerySetEqual(
+ c4.secondary_article_set.all(),
+ [
+ "Parrot steals",
+ "Parrot runs",
+ ],
+ lambda a: a.headline,
+ )
diff --git a/testbed/django__django/tests/m2m_recursive/__init__.py b/testbed/django__django/tests/m2m_recursive/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testbed/django__django/tests/m2m_recursive/models.py b/testbed/django__django/tests/m2m_recursive/models.py
new file mode 100644
index 0000000000000000000000000000000000000000..3bc6738abcac828246bf297574bfabbfb2c63208
--- /dev/null
+++ b/testbed/django__django/tests/m2m_recursive/models.py
@@ -0,0 +1,35 @@
+"""
+Many-to-many relationships between the same two tables
+
+In this example, a ``Person`` can have many friends, who are also ``Person``
+objects. Friendship is a symmetrical relationship - if I am your friend, you
+are my friend. Here, ``friends`` is an example of a symmetrical
+``ManyToManyField``.
+
+A ``Person`` can also have many idols - but while I may idolize you, you may
+not think the same of me. Here, ``idols`` is an example of a non-symmetrical
+``ManyToManyField``. Only recursive ``ManyToManyField`` fields may be
+non-symmetrical, and they are symmetrical by default.
+
+This test validates that the many-to-many table is created using a mangled name
+if there is a name clash, and tests that symmetry is preserved where
+appropriate.
+"""
+
+from django.db import models
+
+
+class Person(models.Model):
+ name = models.CharField(max_length=20)
+ friends = models.ManyToManyField("self")
+ colleagues = models.ManyToManyField("self", symmetrical=True, through="Colleague")
+ idols = models.ManyToManyField("self", symmetrical=False, related_name="stalkers")
+
+ def __str__(self):
+ return self.name
+
+
+class Colleague(models.Model):
+ first = models.ForeignKey(Person, models.CASCADE)
+ second = models.ForeignKey(Person, models.CASCADE, related_name="+")
+ first_meet = models.DateField()
diff --git a/testbed/django__django/tests/m2m_recursive/tests.py b/testbed/django__django/tests/m2m_recursive/tests.py
new file mode 100644
index 0000000000000000000000000000000000000000..e018434327c69ebd57c3b8606e4a6c88e45ef5a7
--- /dev/null
+++ b/testbed/django__django/tests/m2m_recursive/tests.py
@@ -0,0 +1,133 @@
+import datetime
+
+from django.test import TestCase
+
+from .models import Person
+
+
+class RecursiveM2MTests(TestCase):
+ @classmethod
+ def setUpTestData(cls):
+ cls.a, cls.b, cls.c, cls.d = [
+ Person.objects.create(name=name)
+ for name in ["Anne", "Bill", "Chuck", "David"]
+ ]
+ cls.a.friends.add(cls.b, cls.c)
+ # Add m2m for Anne and Chuck in reverse direction.
+ cls.d.friends.add(cls.a, cls.c)
+
+ def test_recursive_m2m_all(self):
+ for person, friends in (
+ (self.a, [self.b, self.c, self.d]),
+ (self.b, [self.a]),
+ (self.c, [self.a, self.d]),
+ (self.d, [self.a, self.c]),
+ ):
+ with self.subTest(person=person):
+ self.assertSequenceEqual(person.friends.all(), friends)
+
+ def test_recursive_m2m_reverse_add(self):
+ # Add m2m for Anne in reverse direction.
+ self.b.friends.add(self.a)
+ self.assertSequenceEqual(self.a.friends.all(), [self.b, self.c, self.d])
+ self.assertSequenceEqual(self.b.friends.all(), [self.a])
+
+ def test_recursive_m2m_remove(self):
+ self.b.friends.remove(self.a)
+ self.assertSequenceEqual(self.a.friends.all(), [self.c, self.d])
+ self.assertSequenceEqual(self.b.friends.all(), [])
+
+ def test_recursive_m2m_clear(self):
+ # Clear m2m for Anne.
+ self.a.friends.clear()
+ self.assertSequenceEqual(self.a.friends.all(), [])
+ # Reverse m2m relationships should be removed.
+ self.assertSequenceEqual(self.c.friends.all(), [self.d])
+ self.assertSequenceEqual(self.d.friends.all(), [self.c])
+
+ def test_recursive_m2m_add_via_related_name(self):
+ # Add m2m with custom related name for Anne in reverse direction.
+ self.d.stalkers.add(self.a)
+ self.assertSequenceEqual(self.a.idols.all(), [self.d])
+ self.assertSequenceEqual(self.a.stalkers.all(), [])
+
+ def test_recursive_m2m_add_in_both_directions(self):
+ # Adding the same relation twice results in a single relation.
+ self.a.idols.add(self.d)
+ self.d.stalkers.add(self.a)
+ self.assertSequenceEqual(self.a.idols.all(), [self.d])
+
+ def test_recursive_m2m_related_to_self(self):
+ self.a.idols.add(self.a)
+ self.assertSequenceEqual(self.a.idols.all(), [self.a])
+ self.assertSequenceEqual(self.a.stalkers.all(), [self.a])
+
+
+class RecursiveSymmetricalM2MThroughTests(TestCase):
+ @classmethod
+ def setUpTestData(cls):
+ cls.a, cls.b, cls.c, cls.d = [
+ Person.objects.create(name=name)
+ for name in ["Anne", "Bill", "Chuck", "David"]
+ ]
+ cls.a.colleagues.add(
+ cls.b,
+ cls.c,
+ through_defaults={
+ "first_meet": datetime.date(2013, 1, 5),
+ },
+ )
+ # Add m2m for Anne and Chuck in reverse direction.
+ cls.d.colleagues.add(
+ cls.a,
+ cls.c,
+ through_defaults={
+ "first_meet": datetime.date(2015, 6, 15),
+ },
+ )
+
+ def test_recursive_m2m_all(self):
+ for person, colleagues in (
+ (self.a, [self.b, self.c, self.d]),
+ (self.b, [self.a]),
+ (self.c, [self.a, self.d]),
+ (self.d, [self.a, self.c]),
+ ):
+ with self.subTest(person=person):
+ self.assertSequenceEqual(person.colleagues.all(), colleagues)
+
+ def test_recursive_m2m_reverse_add(self):
+ # Add m2m for Anne in reverse direction.
+ self.b.colleagues.add(
+ self.a,
+ through_defaults={
+ "first_meet": datetime.date(2013, 1, 5),
+ },
+ )
+ self.assertCountEqual(self.a.colleagues.all(), [self.b, self.c, self.d])
+ self.assertSequenceEqual(self.b.colleagues.all(), [self.a])
+
+ def test_recursive_m2m_remove(self):
+ self.b.colleagues.remove(self.a)
+ self.assertSequenceEqual(self.a.colleagues.all(), [self.c, self.d])
+ self.assertSequenceEqual(self.b.colleagues.all(), [])
+
+ def test_recursive_m2m_clear(self):
+ # Clear m2m for Anne.
+ self.a.colleagues.clear()
+ self.assertSequenceEqual(self.a.friends.all(), [])
+ # Reverse m2m relationships is removed.
+ self.assertSequenceEqual(self.c.colleagues.all(), [self.d])
+ self.assertSequenceEqual(self.d.colleagues.all(), [self.c])
+
+ def test_recursive_m2m_set(self):
+ # Set new relationships for Chuck.
+ self.c.colleagues.set(
+ [self.b, self.d],
+ through_defaults={
+ "first_meet": datetime.date(2013, 1, 5),
+ },
+ )
+ self.assertSequenceEqual(self.c.colleagues.order_by("name"), [self.b, self.d])
+ # Reverse m2m relationships is removed.
+ self.assertSequenceEqual(self.a.colleagues.order_by("name"), [self.b, self.d])
diff --git a/testbed/django__django/tests/m2m_regress/__init__.py b/testbed/django__django/tests/m2m_regress/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testbed/django__django/tests/m2m_regress/models.py b/testbed/django__django/tests/m2m_regress/models.py
new file mode 100644
index 0000000000000000000000000000000000000000..0e6cec3b6a61d9ef1b0d5c65b6da5628f71396e7
--- /dev/null
+++ b/testbed/django__django/tests/m2m_regress/models.py
@@ -0,0 +1,95 @@
+from django.contrib.auth import models as auth
+from django.db import models
+
+
+# No related name is needed here, since symmetrical relations are not
+# explicitly reversible.
+class SelfRefer(models.Model):
+ name = models.CharField(max_length=10)
+ references = models.ManyToManyField("self")
+ related = models.ManyToManyField("self")
+
+ def __str__(self):
+ return self.name
+
+
+class Tag(models.Model):
+ name = models.CharField(max_length=10)
+
+ def __str__(self):
+ return self.name
+
+
+# Regression for #11956 -- a many to many to the base class
+class TagCollection(Tag):
+ tags = models.ManyToManyField(Tag, related_name="tag_collections")
+
+ def __str__(self):
+ return self.name
+
+
+# A related_name is required on one of the ManyToManyField entries here because
+# they are both addressable as reverse relations from Tag.
+class Entry(models.Model):
+ name = models.CharField(max_length=10)
+ topics = models.ManyToManyField(Tag)
+ related = models.ManyToManyField(Tag, related_name="similar")
+
+ def __str__(self):
+ return self.name
+
+
+# Two models both inheriting from a base model with a self-referential m2m field
+class SelfReferChild(SelfRefer):
+ pass
+
+
+class SelfReferChildSibling(SelfRefer):
+ pass
+
+
+# Many-to-Many relation between models, where one of the PK's isn't an Autofield
+class Line(models.Model):
+ name = models.CharField(max_length=100)
+
+ def __str__(self):
+ return self.name
+
+
+class Worksheet(models.Model):
+ id = models.CharField(primary_key=True, max_length=100)
+ lines = models.ManyToManyField(Line, blank=True)
+
+
+# Regression for #11226 -- A model with the same name that another one to
+# which it has a m2m relation. This shouldn't cause a name clash between
+# the automatically created m2m intermediary table FK field names when
+# running migrate
+class User(models.Model):
+ name = models.CharField(max_length=30)
+ friends = models.ManyToManyField(auth.User)
+
+
+class BadModelWithSplit(models.Model):
+ name = models.CharField(max_length=1)
+
+ class Meta:
+ abstract = True
+
+ def split(self):
+ raise RuntimeError("split should not be called")
+
+
+class RegressionModelSplit(BadModelWithSplit):
+ """
+ Model with a split method should not cause an error in add_lazy_relation
+ """
+
+ others = models.ManyToManyField("self")
+
+
+# Regression for #24505 -- Two ManyToManyFields with the same "to" model
+# and related_name set to '+'.
+class Post(models.Model):
+ primary_lines = models.ManyToManyField(Line, related_name="+")
+ secondary_lines = models.ManyToManyField(Line, related_name="+")
diff --git a/testbed/django__django/tests/m2m_regress/tests.py b/testbed/django__django/tests/m2m_regress/tests.py
new file mode 100644
index 0000000000000000000000000000000000000000..d3f352ffd926eae26b02e3f8144ad03b614df68d
--- /dev/null
+++ b/testbed/django__django/tests/m2m_regress/tests.py
@@ -0,0 +1,143 @@
+from django.core.exceptions import FieldError
+from django.test import TestCase
+
+from .models import (
+ Entry,
+ Line,
+ Post,
+ RegressionModelSplit,
+ SelfRefer,
+ SelfReferChild,
+ SelfReferChildSibling,
+ Tag,
+ TagCollection,
+ Worksheet,
+)
+
+
+class M2MRegressionTests(TestCase):
+ def test_multiple_m2m(self):
+ # Multiple m2m references to model must be distinguished when
+ # accessing the relations through an instance attribute.
+
+ s1 = SelfRefer.objects.create(name="s1")
+ s2 = SelfRefer.objects.create(name="s2")
+ s3 = SelfRefer.objects.create(name="s3")
+ s1.references.add(s2)
+ s1.related.add(s3)
+
+ e1 = Entry.objects.create(name="e1")
+ t1 = Tag.objects.create(name="t1")
+ t2 = Tag.objects.create(name="t2")
+
+ e1.topics.add(t1)
+ e1.related.add(t2)
+
+ self.assertSequenceEqual(s1.references.all(), [s2])
+ self.assertSequenceEqual(s1.related.all(), [s3])
+
+ self.assertSequenceEqual(e1.topics.all(), [t1])
+ self.assertSequenceEqual(e1.related.all(), [t2])
+
+ def test_internal_related_name_not_in_error_msg(self):
+ # The secret internal related names for self-referential many-to-many
+ # fields shouldn't appear in the list when an error is made.
+ msg = (
+ "Choices are: id, name, references, related, selfreferchild, "
+ "selfreferchildsibling"
+ )
+ with self.assertRaisesMessage(FieldError, msg):
+ SelfRefer.objects.filter(porcupine="fred")
+
+ def test_m2m_inheritance_symmetry(self):
+ # Test to ensure that the relationship between two inherited models
+ # with a self-referential m2m field maintains symmetry
+
+ sr_child = SelfReferChild(name="Hanna")
+ sr_child.save()
+
+ sr_sibling = SelfReferChildSibling(name="Beth")
+ sr_sibling.save()
+ sr_child.related.add(sr_sibling)
+
+ self.assertSequenceEqual(sr_child.related.all(), [sr_sibling.selfrefer_ptr])
+ self.assertSequenceEqual(sr_sibling.related.all(), [sr_child.selfrefer_ptr])
+
+ def test_m2m_pk_field_type(self):
+ # Regression for #11311 - The primary key for models in a m2m relation
+ # doesn't have to be an AutoField
+
+ w = Worksheet(id="abc")
+ w.save()
+ w.delete()
+
+ def test_create_copy_with_m2m(self):
+ t1 = Tag.objects.create(name="t1")
+ Entry.objects.create(name="e1")
+ entry = Entry.objects.first()
+ entry.topics.set([t1])
+ old_topics = entry.topics.all()
+ entry.pk = None
+ entry._state.adding = True
+ entry.save()
+ entry.topics.set(old_topics)
+ entry = Entry.objects.get(pk=entry.pk)
+ self.assertCountEqual(entry.topics.all(), old_topics)
+ self.assertSequenceEqual(entry.topics.all(), [t1])
+
+ def test_add_m2m_with_base_class(self):
+ # Regression for #11956 -- You can add an object to a m2m with the
+ # base class without causing integrity errors
+
+ t1 = Tag.objects.create(name="t1")
+ t2 = Tag.objects.create(name="t2")
+
+ c1 = TagCollection.objects.create(name="c1")
+ c1.tags.set([t1, t2])
+ c1 = TagCollection.objects.get(name="c1")
+
+ self.assertCountEqual(c1.tags.all(), [t1, t2])
+ self.assertCountEqual(t1.tag_collections.all(), [c1])
+
+ def test_manager_class_caching(self):
+ e1 = Entry.objects.create()
+ e2 = Entry.objects.create()
+ t1 = Tag.objects.create()
+ t2 = Tag.objects.create()
+
+ # Get same manager twice in a row:
+ self.assertIs(t1.entry_set.__class__, t1.entry_set.__class__)
+ self.assertIs(e1.topics.__class__, e1.topics.__class__)
+
+ # Get same manager for different instances
+ self.assertIs(e1.topics.__class__, e2.topics.__class__)
+ self.assertIs(t1.entry_set.__class__, t2.entry_set.__class__)
+
+ def test_m2m_abstract_split(self):
+ # Regression for #19236 - an abstract class with a 'split' method
+ # causes a TypeError in add_lazy_relation
+ m1 = RegressionModelSplit(name="1")
+ m1.save()
+
+ def test_assigning_invalid_data_to_m2m_doesnt_clear_existing_relations(self):
+ t1 = Tag.objects.create(name="t1")
+ t2 = Tag.objects.create(name="t2")
+ c1 = TagCollection.objects.create(name="c1")
+ c1.tags.set([t1, t2])
+
+ with self.assertRaisesMessage(TypeError, "'int' object is not iterable"):
+ c1.tags.set(7)
+
+ c1.refresh_from_db()
+ self.assertSequenceEqual(c1.tags.order_by("name"), [t1, t2])
+
+ def test_multiple_forwards_only_m2m(self):
+ # Regression for #24505 - Multiple ManyToManyFields to same "to"
+ # model with related_name set to '+'.
+ foo = Line.objects.create(name="foo")
+ bar = Line.objects.create(name="bar")
+ post = Post.objects.create()
+ post.primary_lines.add(foo)
+ post.secondary_lines.add(bar)
+ self.assertSequenceEqual(post.primary_lines.all(), [foo])
+ self.assertSequenceEqual(post.secondary_lines.all(), [bar])
diff --git a/testbed/django__django/tests/m2m_signals/__init__.py b/testbed/django__django/tests/m2m_signals/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testbed/django__django/tests/m2m_signals/models.py b/testbed/django__django/tests/m2m_signals/models.py
new file mode 100644
index 0000000000000000000000000000000000000000..17bdae2ae25c24911c4f92b5fa669299c2f5362b
--- /dev/null
+++ b/testbed/django__django/tests/m2m_signals/models.py
@@ -0,0 +1,30 @@
+from django.db import models
+
+
+class Part(models.Model):
+ name = models.CharField(max_length=20)
+
+ class Meta:
+ ordering = ("name",)
+
+
+class Car(models.Model):
+ name = models.CharField(max_length=20)
+ default_parts = models.ManyToManyField(Part)
+ optional_parts = models.ManyToManyField(Part, related_name="cars_optional")
+
+ class Meta:
+ ordering = ("name",)
+
+
+class SportsCar(Car):
+ price = models.IntegerField()
+
+
+class Person(models.Model):
+ name = models.CharField(max_length=20)
+ fans = models.ManyToManyField("self", related_name="idols", symmetrical=False)
+ friends = models.ManyToManyField("self")
+
+ class Meta:
+ ordering = ("name",)
diff --git a/testbed/django__django/tests/m2m_signals/tests.py b/testbed/django__django/tests/m2m_signals/tests.py
new file mode 100644
index 0000000000000000000000000000000000000000..488c0a6fbe7790abbf979492a282a5bea256d4ce
--- /dev/null
+++ b/testbed/django__django/tests/m2m_signals/tests.py
@@ -0,0 +1,578 @@
+"""
+Testing signals emitted on changing m2m relations.
+"""
+
+from django.db import models
+from django.test import TestCase
+
+from .models import Car, Part, Person, SportsCar
+
+
+class ManyToManySignalsTest(TestCase):
+ @classmethod
+ def setUpTestData(cls):
+ cls.vw = Car.objects.create(name="VW")
+ cls.bmw = Car.objects.create(name="BMW")
+ cls.toyota = Car.objects.create(name="Toyota")
+
+ cls.wheelset = Part.objects.create(name="Wheelset")
+ cls.doors = Part.objects.create(name="Doors")
+ cls.engine = Part.objects.create(name="Engine")
+ cls.airbag = Part.objects.create(name="Airbag")
+ cls.sunroof = Part.objects.create(name="Sunroof")
+
+ cls.alice = Person.objects.create(name="Alice")
+ cls.bob = Person.objects.create(name="Bob")
+ cls.chuck = Person.objects.create(name="Chuck")
+ cls.daisy = Person.objects.create(name="Daisy")
+
+ def setUp(self):
+ self.m2m_changed_messages = []
+
+ def m2m_changed_signal_receiver(self, signal, sender, **kwargs):
+ message = {
+ "instance": kwargs["instance"],
+ "action": kwargs["action"],
+ "reverse": kwargs["reverse"],
+ "model": kwargs["model"],
+ }
+ if kwargs["pk_set"]:
+ message["objects"] = list(
+ kwargs["model"].objects.filter(pk__in=kwargs["pk_set"])
+ )
+ self.m2m_changed_messages.append(message)
+
+ def tearDown(self):
+ # disconnect all signal handlers
+ models.signals.m2m_changed.disconnect(
+ self.m2m_changed_signal_receiver, Car.default_parts.through
+ )
+ models.signals.m2m_changed.disconnect(
+ self.m2m_changed_signal_receiver, Car.optional_parts.through
+ )
+ models.signals.m2m_changed.disconnect(
+ self.m2m_changed_signal_receiver, Person.fans.through
+ )
+ models.signals.m2m_changed.disconnect(
+ self.m2m_changed_signal_receiver, Person.friends.through
+ )
+
+ def _initialize_signal_car(self, add_default_parts_before_set_signal=False):
+ """Install a listener on the two m2m relations."""
+ models.signals.m2m_changed.connect(
+ self.m2m_changed_signal_receiver, Car.optional_parts.through
+ )
+ if add_default_parts_before_set_signal:
+ # adding a default part to our car - no signal listener installed
+ self.vw.default_parts.add(self.sunroof)
+ models.signals.m2m_changed.connect(
+ self.m2m_changed_signal_receiver, Car.default_parts.through
+ )
+
+ def test_pk_set_on_repeated_add_remove(self):
+ """
+ m2m_changed is always fired, even for repeated calls to the same
+ method, but the behavior of pk_sets differs by action.
+
+ - For signals related to `add()`, only PKs that will actually be
+ inserted are sent.
+ - For `remove()` all PKs are sent, even if they will not affect the DB.
+ """
+ pk_sets_sent = []
+
+ def handler(signal, sender, **kwargs):
+ if kwargs["action"] in ["pre_add", "pre_remove"]:
+ pk_sets_sent.append(kwargs["pk_set"])
+
+ models.signals.m2m_changed.connect(handler, Car.default_parts.through)
+
+ self.vw.default_parts.add(self.wheelset)
+ self.vw.default_parts.add(self.wheelset)
+
+ self.vw.default_parts.remove(self.wheelset)
+ self.vw.default_parts.remove(self.wheelset)
+
+ expected_pk_sets = [
+ {self.wheelset.pk},
+ set(),
+ {self.wheelset.pk},
+ {self.wheelset.pk},
+ ]
+ self.assertEqual(pk_sets_sent, expected_pk_sets)
+
+ models.signals.m2m_changed.disconnect(handler, Car.default_parts.through)
+
+ def test_m2m_relations_add_remove_clear(self):
+ expected_messages = []
+
+ self._initialize_signal_car(add_default_parts_before_set_signal=True)
+
+ self.vw.default_parts.add(self.wheelset, self.doors, self.engine)
+ expected_messages.append(
+ {
+ "instance": self.vw,
+ "action": "pre_add",
+ "reverse": False,
+ "model": Part,
+ "objects": [self.doors, self.engine, self.wheelset],
+ }
+ )
+ expected_messages.append(
+ {
+ "instance": self.vw,
+ "action": "post_add",
+ "reverse": False,
+ "model": Part,
+ "objects": [self.doors, self.engine, self.wheelset],
+ }
+ )
+ self.assertEqual(self.m2m_changed_messages, expected_messages)
+
+ # give the BMW and Toyota some doors as well
+ self.doors.car_set.add(self.bmw, self.toyota)
+ expected_messages.append(
+ {
+ "instance": self.doors,
+ "action": "pre_add",
+ "reverse": True,
+ "model": Car,
+ "objects": [self.bmw, self.toyota],
+ }
+ )
+ expected_messages.append(
+ {
+ "instance": self.doors,
+ "action": "post_add",
+ "reverse": True,
+ "model": Car,
+ "objects": [self.bmw, self.toyota],
+ }
+ )
+ self.assertEqual(self.m2m_changed_messages, expected_messages)
+
+ def test_m2m_relations_signals_remove_relation(self):
+ self._initialize_signal_car()
+ # remove the engine from the self.vw and the airbag (which is not set
+ # but is returned)
+ self.vw.default_parts.remove(self.engine, self.airbag)
+ self.assertEqual(
+ self.m2m_changed_messages,
+ [
+ {
+ "instance": self.vw,
+ "action": "pre_remove",
+ "reverse": False,
+ "model": Part,
+ "objects": [self.airbag, self.engine],
+ },
+ {
+ "instance": self.vw,
+ "action": "post_remove",
+ "reverse": False,
+ "model": Part,
+ "objects": [self.airbag, self.engine],
+ },
+ ],
+ )
+
+ def test_m2m_relations_signals_give_the_self_vw_some_optional_parts(self):
+ expected_messages = []
+
+ self._initialize_signal_car()
+
+ # give the self.vw some optional parts (second relation to same model)
+ self.vw.optional_parts.add(self.airbag, self.sunroof)
+ expected_messages.append(
+ {
+ "instance": self.vw,
+ "action": "pre_add",
+ "reverse": False,
+ "model": Part,
+ "objects": [self.airbag, self.sunroof],
+ }
+ )
+ expected_messages.append(
+ {
+ "instance": self.vw,
+ "action": "post_add",
+ "reverse": False,
+ "model": Part,
+ "objects": [self.airbag, self.sunroof],
+ }
+ )
+ self.assertEqual(self.m2m_changed_messages, expected_messages)
+
+ # add airbag to all the cars (even though the self.vw already has one)
+ self.airbag.cars_optional.add(self.vw, self.bmw, self.toyota)
+ expected_messages.append(
+ {
+ "instance": self.airbag,
+ "action": "pre_add",
+ "reverse": True,
+ "model": Car,
+ "objects": [self.bmw, self.toyota],
+ }
+ )
+ expected_messages.append(
+ {
+ "instance": self.airbag,
+ "action": "post_add",
+ "reverse": True,
+ "model": Car,
+ "objects": [self.bmw, self.toyota],
+ }
+ )
+ self.assertEqual(self.m2m_changed_messages, expected_messages)
+
+ def test_m2m_relations_signals_reverse_relation_with_custom_related_name(self):
+ self._initialize_signal_car()
+ # remove airbag from the self.vw (reverse relation with custom
+ # related_name)
+ self.airbag.cars_optional.remove(self.vw)
+ self.assertEqual(
+ self.m2m_changed_messages,
+ [
+ {
+ "instance": self.airbag,
+ "action": "pre_remove",
+ "reverse": True,
+ "model": Car,
+ "objects": [self.vw],
+ },
+ {
+ "instance": self.airbag,
+ "action": "post_remove",
+ "reverse": True,
+ "model": Car,
+ "objects": [self.vw],
+ },
+ ],
+ )
+
+ def test_m2m_relations_signals_clear_all_parts_of_the_self_vw(self):
+ self._initialize_signal_car()
+ # clear all parts of the self.vw
+ self.vw.default_parts.clear()
+ self.assertEqual(
+ self.m2m_changed_messages,
+ [
+ {
+ "instance": self.vw,
+ "action": "pre_clear",
+ "reverse": False,
+ "model": Part,
+ },
+ {
+ "instance": self.vw,
+ "action": "post_clear",
+ "reverse": False,
+ "model": Part,
+ },
+ ],
+ )
+
+ def test_m2m_relations_signals_all_the_doors_off_of_cars(self):
+ self._initialize_signal_car()
+ # take all the doors off of cars
+ self.doors.car_set.clear()
+ self.assertEqual(
+ self.m2m_changed_messages,
+ [
+ {
+ "instance": self.doors,
+ "action": "pre_clear",
+ "reverse": True,
+ "model": Car,
+ },
+ {
+ "instance": self.doors,
+ "action": "post_clear",
+ "reverse": True,
+ "model": Car,
+ },
+ ],
+ )
+
+ def test_m2m_relations_signals_reverse_relation(self):
+ self._initialize_signal_car()
+ # take all the airbags off of cars (clear reverse relation with custom
+ # related_name)
+ self.airbag.cars_optional.clear()
+ self.assertEqual(
+ self.m2m_changed_messages,
+ [
+ {
+ "instance": self.airbag,
+ "action": "pre_clear",
+ "reverse": True,
+ "model": Car,
+ },
+ {
+ "instance": self.airbag,
+ "action": "post_clear",
+ "reverse": True,
+ "model": Car,
+ },
+ ],
+ )
+
+ def test_m2m_relations_signals_alternative_ways(self):
+ expected_messages = []
+
+ self._initialize_signal_car()
+
+ # alternative ways of setting relation:
+ self.vw.default_parts.create(name="Windows")
+ p6 = Part.objects.get(name="Windows")
+ expected_messages.append(
+ {
+ "instance": self.vw,
+ "action": "pre_add",
+ "reverse": False,
+ "model": Part,
+ "objects": [p6],
+ }
+ )
+ expected_messages.append(
+ {
+ "instance": self.vw,
+ "action": "post_add",
+ "reverse": False,
+ "model": Part,
+ "objects": [p6],
+ }
+ )
+ self.assertEqual(self.m2m_changed_messages, expected_messages)
+
+ # direct assignment clears the set first, then adds
+ self.vw.default_parts.set([self.wheelset, self.doors, self.engine])
+ expected_messages.append(
+ {
+ "instance": self.vw,
+ "action": "pre_remove",
+ "reverse": False,
+ "model": Part,
+ "objects": [p6],
+ }
+ )
+ expected_messages.append(
+ {
+ "instance": self.vw,
+ "action": "post_remove",
+ "reverse": False,
+ "model": Part,
+ "objects": [p6],
+ }
+ )
+ expected_messages.append(
+ {
+ "instance": self.vw,
+ "action": "pre_add",
+ "reverse": False,
+ "model": Part,
+ "objects": [self.doors, self.engine, self.wheelset],
+ }
+ )
+ expected_messages.append(
+ {
+ "instance": self.vw,
+ "action": "post_add",
+ "reverse": False,
+ "model": Part,
+ "objects": [self.doors, self.engine, self.wheelset],
+ }
+ )
+ self.assertEqual(self.m2m_changed_messages, expected_messages)
+
+ def test_m2m_relations_signals_clearing_removing(self):
+ expected_messages = []
+
+ self._initialize_signal_car(add_default_parts_before_set_signal=True)
+
+ # set by clearing.
+ self.vw.default_parts.set([self.wheelset, self.doors, self.engine], clear=True)
+ expected_messages.append(
+ {
+ "instance": self.vw,
+ "action": "pre_clear",
+ "reverse": False,
+ "model": Part,
+ }
+ )
+ expected_messages.append(
+ {
+ "instance": self.vw,
+ "action": "post_clear",
+ "reverse": False,
+ "model": Part,
+ }
+ )
+ expected_messages.append(
+ {
+ "instance": self.vw,
+ "action": "pre_add",
+ "reverse": False,
+ "model": Part,
+ "objects": [self.doors, self.engine, self.wheelset],
+ }
+ )
+ expected_messages.append(
+ {
+ "instance": self.vw,
+ "action": "post_add",
+ "reverse": False,
+ "model": Part,
+ "objects": [self.doors, self.engine, self.wheelset],
+ }
+ )
+ self.assertEqual(self.m2m_changed_messages, expected_messages)
+
+ # set by only removing what's necessary.
+ self.vw.default_parts.set([self.wheelset, self.doors], clear=False)
+ expected_messages.append(
+ {
+ "instance": self.vw,
+ "action": "pre_remove",
+ "reverse": False,
+ "model": Part,
+ "objects": [self.engine],
+ }
+ )
+ expected_messages.append(
+ {
+ "instance": self.vw,
+ "action": "post_remove",
+ "reverse": False,
+ "model": Part,
+ "objects": [self.engine],
+ }
+ )
+ self.assertEqual(self.m2m_changed_messages, expected_messages)
+
+ def test_m2m_relations_signals_when_inheritance(self):
+ expected_messages = []
+
+ self._initialize_signal_car(add_default_parts_before_set_signal=True)
+
+ # Signals still work when model inheritance is involved
+ c4 = SportsCar.objects.create(name="Bugatti", price="1000000")
+ c4b = Car.objects.get(name="Bugatti")
+ c4.default_parts.set([self.doors])
+ expected_messages.append(
+ {
+ "instance": c4,
+ "action": "pre_add",
+ "reverse": False,
+ "model": Part,
+ "objects": [self.doors],
+ }
+ )
+ expected_messages.append(
+ {
+ "instance": c4,
+ "action": "post_add",
+ "reverse": False,
+ "model": Part,
+ "objects": [self.doors],
+ }
+ )
+ self.assertEqual(self.m2m_changed_messages, expected_messages)
+
+ self.engine.car_set.add(c4)
+ expected_messages.append(
+ {
+ "instance": self.engine,
+ "action": "pre_add",
+ "reverse": True,
+ "model": Car,
+ "objects": [c4b],
+ }
+ )
+ expected_messages.append(
+ {
+ "instance": self.engine,
+ "action": "post_add",
+ "reverse": True,
+ "model": Car,
+ "objects": [c4b],
+ }
+ )
+ self.assertEqual(self.m2m_changed_messages, expected_messages)
+
+ def _initialize_signal_person(self):
+ # Install a listener on the two m2m relations.
+ models.signals.m2m_changed.connect(
+ self.m2m_changed_signal_receiver, Person.fans.through
+ )
+ models.signals.m2m_changed.connect(
+ self.m2m_changed_signal_receiver, Person.friends.through
+ )
+
+ def test_m2m_relations_with_self_add_friends(self):
+ self._initialize_signal_person()
+ self.alice.friends.set([self.bob, self.chuck])
+ self.assertEqual(
+ self.m2m_changed_messages,
+ [
+ {
+ "instance": self.alice,
+ "action": "pre_add",
+ "reverse": False,
+ "model": Person,
+ "objects": [self.bob, self.chuck],
+ },
+ {
+ "instance": self.alice,
+ "action": "post_add",
+ "reverse": False,
+ "model": Person,
+ "objects": [self.bob, self.chuck],
+ },
+ ],
+ )
+
+ def test_m2m_relations_with_self_add_fan(self):
+ self._initialize_signal_person()
+ self.alice.fans.set([self.daisy])
+ self.assertEqual(
+ self.m2m_changed_messages,
+ [
+ {
+ "instance": self.alice,
+ "action": "pre_add",
+ "reverse": False,
+ "model": Person,
+ "objects": [self.daisy],
+ },
+ {
+ "instance": self.alice,
+ "action": "post_add",
+ "reverse": False,
+ "model": Person,
+ "objects": [self.daisy],
+ },
+ ],
+ )
+
+ def test_m2m_relations_with_self_add_idols(self):
+ self._initialize_signal_person()
+ self.chuck.idols.set([self.alice, self.bob])
+ self.assertEqual(
+ self.m2m_changed_messages,
+ [
+ {
+ "instance": self.chuck,
+ "action": "pre_add",
+ "reverse": True,
+ "model": Person,
+ "objects": [self.alice, self.bob],
+ },
+ {
+ "instance": self.chuck,
+ "action": "post_add",
+ "reverse": True,
+ "model": Person,
+ "objects": [self.alice, self.bob],
+ },
+ ],
+ )
diff --git a/testbed/django__django/tests/m2m_through/__init__.py b/testbed/django__django/tests/m2m_through/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testbed/django__django/tests/m2m_through/models.py b/testbed/django__django/tests/m2m_through/models.py
new file mode 100644
index 0000000000000000000000000000000000000000..47a0b75f4bbbfdf6901a4b911348b9adbf2024ab
--- /dev/null
+++ b/testbed/django__django/tests/m2m_through/models.py
@@ -0,0 +1,157 @@
+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")
diff --git a/testbed/django__django/tests/m2m_through/tests.py b/testbed/django__django/tests/m2m_through/tests.py
new file mode 100644
index 0000000000000000000000000000000000000000..83449a7c7b7455ad50c5731ae80ff3476273f426
--- /dev/null
+++ b/testbed/django__django/tests/m2m_through/tests.py
@@ -0,0 +1,535 @@
+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), "")
+
+ 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"],
+ )
diff --git a/testbed/django__django/tests/m2m_through_regress/__init__.py b/testbed/django__django/tests/m2m_through_regress/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testbed/django__django/tests/m2m_through_regress/fixtures/m2m_through.json b/testbed/django__django/tests/m2m_through_regress/fixtures/m2m_through.json
new file mode 100644
index 0000000000000000000000000000000000000000..6f24886f02ea2bb7afeb3db59f21b119258b7776
--- /dev/null
+++ b/testbed/django__django/tests/m2m_through_regress/fixtures/m2m_through.json
@@ -0,0 +1,34 @@
+[
+ {
+ "pk": "1",
+ "model": "m2m_through_regress.person",
+ "fields": {
+ "name": "Guido"
+ }
+ },
+ {
+ "pk": "1",
+ "model": "auth.user",
+ "fields": {
+ "username": "Guido",
+ "email": "bdfl@python.org",
+ "password": "abcde"
+ }
+ },
+ {
+ "pk": "1",
+ "model": "m2m_through_regress.group",
+ "fields": {
+ "name": "Python Core Group"
+ }
+ },
+ {
+ "pk": "1",
+ "model": "m2m_through_regress.usermembership",
+ "fields": {
+ "user": "1",
+ "group": "1",
+ "price": "100"
+ }
+ }
+]
\ No newline at end of file
diff --git a/testbed/django__django/tests/m2m_through_regress/models.py b/testbed/django__django/tests/m2m_through_regress/models.py
new file mode 100644
index 0000000000000000000000000000000000000000..db724e43d25504dbc6d3f83fdf8f4cd036622c7b
--- /dev/null
+++ b/testbed/django__django/tests/m2m_through_regress/models.py
@@ -0,0 +1,90 @@
+from django.contrib.auth.models import User
+from django.db import models
+
+
+# Forward declared intermediate model
+class Membership(models.Model):
+ person = models.ForeignKey("Person", models.CASCADE)
+ group = models.ForeignKey("Group", models.CASCADE)
+ price = models.IntegerField(default=100)
+
+
+# using custom id column to test ticket #11107
+class UserMembership(models.Model):
+ id = models.AutoField(db_column="usermembership_id", primary_key=True)
+ user = models.ForeignKey(User, models.CASCADE)
+ group = models.ForeignKey("Group", models.CASCADE)
+ price = models.IntegerField(default=100)
+
+
+class Person(models.Model):
+ name = models.CharField(max_length=128)
+
+ def __str__(self):
+ return self.name
+
+
+class Group(models.Model):
+ name = models.CharField(max_length=128)
+ # Membership object defined as a class
+ members = models.ManyToManyField(Person, through=Membership)
+ user_members = models.ManyToManyField(User, through="UserMembership")
+
+ def __str__(self):
+ return self.name
+
+
+# Using to_field on the through model
+class Car(models.Model):
+ make = models.CharField(max_length=20, unique=True, null=True)
+ drivers = models.ManyToManyField("Driver", through="CarDriver")
+
+ def __str__(self):
+ return str(self.make)
+
+
+class Driver(models.Model):
+ name = models.CharField(max_length=20, unique=True, null=True)
+
+ class Meta:
+ ordering = ("name",)
+
+ def __str__(self):
+ return str(self.name)
+
+
+class CarDriver(models.Model):
+ car = models.ForeignKey("Car", models.CASCADE, to_field="make")
+ driver = models.ForeignKey("Driver", models.CASCADE, to_field="name")
+
+ def __str__(self):
+ return "pk=%s car=%s driver=%s" % (str(self.pk), self.car, self.driver)
+
+
+# Through models using multi-table inheritance
+class Event(models.Model):
+ name = models.CharField(max_length=50, unique=True)
+ people = models.ManyToManyField("Person", through="IndividualCompetitor")
+ special_people = models.ManyToManyField(
+ "Person",
+ through="ProxiedIndividualCompetitor",
+ related_name="special_event_set",
+ )
+ teams = models.ManyToManyField("Group", through="CompetingTeam")
+
+
+class Competitor(models.Model):
+ event = models.ForeignKey(Event, models.CASCADE)
+
+
+class IndividualCompetitor(Competitor):
+ person = models.ForeignKey(Person, models.CASCADE)
+
+
+class CompetingTeam(Competitor):
+ team = models.ForeignKey(Group, models.CASCADE)
+
+
+class ProxiedIndividualCompetitor(IndividualCompetitor):
+ class Meta:
+ proxy = True
diff --git a/testbed/django__django/tests/m2m_through_regress/test_multitable.py b/testbed/django__django/tests/m2m_through_regress/test_multitable.py
new file mode 100644
index 0000000000000000000000000000000000000000..ae3a4060e6d042e4fae7bd995ce7e70a32f8160e
--- /dev/null
+++ b/testbed/django__django/tests/m2m_through_regress/test_multitable.py
@@ -0,0 +1,61 @@
+from django.test import TestCase
+
+from .models import (
+ CompetingTeam,
+ Event,
+ Group,
+ IndividualCompetitor,
+ Membership,
+ Person,
+)
+
+
+class MultiTableTests(TestCase):
+ @classmethod
+ def setUpTestData(cls):
+ cls.alice = Person.objects.create(name="Alice")
+ cls.bob = Person.objects.create(name="Bob")
+ cls.chris = Person.objects.create(name="Chris")
+ cls.dan = Person.objects.create(name="Dan")
+ cls.team_alpha = Group.objects.create(name="Alpha")
+ Membership.objects.create(person=cls.alice, group=cls.team_alpha)
+ Membership.objects.create(person=cls.bob, group=cls.team_alpha)
+ cls.event = Event.objects.create(name="Exposition Match")
+ IndividualCompetitor.objects.create(event=cls.event, person=cls.chris)
+ IndividualCompetitor.objects.create(event=cls.event, person=cls.dan)
+ CompetingTeam.objects.create(event=cls.event, team=cls.team_alpha)
+
+ def test_m2m_query(self):
+ result = self.event.teams.all()
+ self.assertCountEqual(result, [self.team_alpha])
+
+ def test_m2m_reverse_query(self):
+ result = self.chris.event_set.all()
+ self.assertCountEqual(result, [self.event])
+
+ def test_m2m_query_proxied(self):
+ result = self.event.special_people.all()
+ self.assertCountEqual(result, [self.chris, self.dan])
+
+ def test_m2m_reverse_query_proxied(self):
+ result = self.chris.special_event_set.all()
+ self.assertCountEqual(result, [self.event])
+
+ def test_m2m_prefetch_proxied(self):
+ result = Event.objects.filter(name="Exposition Match").prefetch_related(
+ "special_people"
+ )
+ with self.assertNumQueries(2):
+ self.assertCountEqual(result, [self.event])
+ self.assertEqual(
+ sorted(p.name for p in result[0].special_people.all()), ["Chris", "Dan"]
+ )
+
+ def test_m2m_prefetch_reverse_proxied(self):
+ result = Person.objects.filter(name="Dan").prefetch_related("special_event_set")
+ with self.assertNumQueries(2):
+ self.assertCountEqual(result, [self.dan])
+ self.assertEqual(
+ [event.name for event in result[0].special_event_set.all()],
+ ["Exposition Match"],
+ )
diff --git a/testbed/django__django/tests/m2m_through_regress/tests.py b/testbed/django__django/tests/m2m_through_regress/tests.py
new file mode 100644
index 0000000000000000000000000000000000000000..eae151546bd32e3bf0ee433c9a001ca0f6d15938
--- /dev/null
+++ b/testbed/django__django/tests/m2m_through_regress/tests.py
@@ -0,0 +1,239 @@
+from io import StringIO
+
+from django.contrib.auth.models import User
+from django.core import management
+from django.test import TestCase
+
+from .models import Car, CarDriver, Driver, Group, Membership, Person, UserMembership
+
+
+class M2MThroughTestCase(TestCase):
+ @classmethod
+ def setUpTestData(cls):
+ cls.bob = Person.objects.create(name="Bob")
+ cls.jim = Person.objects.create(name="Jim")
+
+ cls.rock = Group.objects.create(name="Rock")
+ cls.roll = Group.objects.create(name="Roll")
+
+ cls.frank = User.objects.create_user("frank", "frank@example.com", "password")
+ cls.jane = User.objects.create_user("jane", "jane@example.com", "password")
+
+ # normal intermediate model
+ cls.bob_rock = Membership.objects.create(person=cls.bob, group=cls.rock)
+ cls.bob_roll = Membership.objects.create(
+ person=cls.bob, group=cls.roll, price=50
+ )
+ cls.jim_rock = Membership.objects.create(
+ person=cls.jim, group=cls.rock, price=50
+ )
+
+ # intermediate model with custom id column
+ cls.frank_rock = UserMembership.objects.create(user=cls.frank, group=cls.rock)
+ cls.frank_roll = UserMembership.objects.create(user=cls.frank, group=cls.roll)
+ cls.jane_rock = UserMembership.objects.create(user=cls.jane, group=cls.rock)
+
+ def test_retrieve_reverse_m2m_items(self):
+ self.assertCountEqual(self.bob.group_set.all(), [self.rock, self.roll])
+
+ def test_retrieve_forward_m2m_items(self):
+ self.assertSequenceEqual(self.roll.members.all(), [self.bob])
+
+ def test_retrieve_reverse_m2m_items_via_custom_id_intermediary(self):
+ self.assertCountEqual(self.frank.group_set.all(), [self.rock, self.roll])
+
+ def test_retrieve_forward_m2m_items_via_custom_id_intermediary(self):
+ self.assertSequenceEqual(self.roll.user_members.all(), [self.frank])
+
+ def test_join_trimming_forwards(self):
+ """
+ Too many copies of the intermediate table aren't involved when doing a
+ join (#8046, #8254).
+ """
+ self.assertSequenceEqual(
+ self.rock.members.filter(membership__price=50),
+ [self.jim],
+ )
+
+ def test_join_trimming_reverse(self):
+ self.assertSequenceEqual(
+ self.bob.group_set.filter(membership__price=50),
+ [self.roll],
+ )
+
+
+class M2MThroughSerializationTestCase(TestCase):
+ @classmethod
+ def setUpTestData(cls):
+ cls.bob = Person.objects.create(name="Bob")
+ cls.roll = Group.objects.create(name="Roll")
+ cls.bob_roll = Membership.objects.create(person=cls.bob, group=cls.roll)
+
+ def test_serialization(self):
+ "m2m-through models aren't serialized as m2m fields. Refs #8134"
+ pks = {
+ "p_pk": self.bob.pk,
+ "g_pk": self.roll.pk,
+ "m_pk": self.bob_roll.pk,
+ "app_label": "m2m_through_regress",
+ }
+
+ out = StringIO()
+ management.call_command(
+ "dumpdata", "m2m_through_regress", format="json", stdout=out
+ )
+ self.assertJSONEqual(
+ out.getvalue().strip(),
+ '[{"pk": %(m_pk)s, "model": "m2m_through_regress.membership", '
+ '"fields": {"person": %(p_pk)s, "price": 100, "group": %(g_pk)s}}, '
+ '{"pk": %(p_pk)s, "model": "m2m_through_regress.person", '
+ '"fields": {"name": "Bob"}}, '
+ '{"pk": %(g_pk)s, "model": "m2m_through_regress.group", '
+ '"fields": {"name": "Roll"}}]' % pks,
+ )
+
+ out = StringIO()
+ management.call_command(
+ "dumpdata", "m2m_through_regress", format="xml", indent=2, stdout=out
+ )
+ self.assertXMLEqual(
+ out.getvalue().strip(),
+ """
+
+
+
+
+
+
+ """.strip()
+ % pks,
+ )
+
+
+class ToFieldThroughTests(TestCase):
+ @classmethod
+ def setUpTestData(cls):
+ cls.car = Car.objects.create(make="Toyota")
+ cls.driver = Driver.objects.create(name="Ryan Briscoe")
+ CarDriver.objects.create(car=cls.car, driver=cls.driver)
+ # We are testing if wrong objects get deleted due to using wrong
+ # field value in m2m queries. So, it is essential that the pk
+ # numberings do not match.
+ # Create one intentionally unused driver to mix up the autonumbering
+ cls.unused_driver = Driver.objects.create(name="Barney Gumble")
+ # And two intentionally unused cars.
+ cls.unused_car1 = Car.objects.create(make="Trabant")
+ cls.unused_car2 = Car.objects.create(make="Wartburg")
+
+ def test_to_field(self):
+ self.assertSequenceEqual(self.car.drivers.all(), [self.driver])
+
+ def test_to_field_reverse(self):
+ self.assertSequenceEqual(self.driver.car_set.all(), [self.car])
+
+ def test_to_field_clear_reverse(self):
+ self.driver.car_set.clear()
+ self.assertSequenceEqual(self.driver.car_set.all(), [])
+
+ def test_to_field_clear(self):
+ self.car.drivers.clear()
+ self.assertSequenceEqual(self.car.drivers.all(), [])
+
+ # Low level tests for _add_items and _remove_items. We test these methods
+ # because .add/.remove aren't available for m2m fields with through, but
+ # through is the only way to set to_field currently. We do want to make
+ # sure these methods are ready if the ability to use .add or .remove with
+ # to_field relations is added some day.
+ def test_add(self):
+ self.assertSequenceEqual(self.car.drivers.all(), [self.driver])
+ # Yikes - barney is going to drive...
+ self.car.drivers._add_items("car", "driver", self.unused_driver)
+ self.assertSequenceEqual(
+ self.car.drivers.all(),
+ [self.unused_driver, self.driver],
+ )
+
+ def test_m2m_relations_unusable_on_null_to_field(self):
+ nullcar = Car(make=None)
+ msg = (
+ '"" needs to have a value for field "make" before this '
+ "many-to-many relationship can be used."
+ )
+ with self.assertRaisesMessage(ValueError, msg):
+ nullcar.drivers.all()
+
+ def test_m2m_relations_unusable_on_null_pk_obj(self):
+ msg = (
+ "'Car' instance needs to have a primary key value before a "
+ "many-to-many relationship can be used."
+ )
+ with self.assertRaisesMessage(ValueError, msg):
+ Car(make="Ford").drivers.all()
+
+ def test_add_related_null(self):
+ nulldriver = Driver.objects.create(name=None)
+ msg = 'Cannot add "": the value for field "driver" is None'
+ with self.assertRaisesMessage(ValueError, msg):
+ self.car.drivers._add_items("car", "driver", nulldriver)
+
+ def test_add_reverse(self):
+ car2 = Car.objects.create(make="Honda")
+ self.assertCountEqual(self.driver.car_set.all(), [self.car])
+ self.driver.car_set._add_items("driver", "car", car2)
+ self.assertCountEqual(self.driver.car_set.all(), [self.car, car2])
+
+ def test_add_null_reverse(self):
+ nullcar = Car.objects.create(make=None)
+ msg = 'Cannot add "": the value for field "car" is None'
+ with self.assertRaisesMessage(ValueError, msg):
+ self.driver.car_set._add_items("driver", "car", nullcar)
+
+ def test_add_null_reverse_related(self):
+ nulldriver = Driver.objects.create(name=None)
+ msg = (
+ '"" needs to have a value for field "name" before '
+ "this many-to-many relationship can be used."
+ )
+ with self.assertRaisesMessage(ValueError, msg):
+ nulldriver.car_set._add_items("driver", "car", self.car)
+
+ def test_remove(self):
+ self.assertSequenceEqual(self.car.drivers.all(), [self.driver])
+ self.car.drivers._remove_items("car", "driver", self.driver)
+ self.assertSequenceEqual(self.car.drivers.all(), [])
+
+ def test_remove_reverse(self):
+ self.assertSequenceEqual(self.driver.car_set.all(), [self.car])
+ self.driver.car_set._remove_items("driver", "car", self.car)
+ self.assertSequenceEqual(self.driver.car_set.all(), [])
+
+
+class ThroughLoadDataTestCase(TestCase):
+ fixtures = ["m2m_through"]
+
+ def test_sequence_creation(self):
+ """
+ Sequences on an m2m_through are created for the through model, not a
+ phantom auto-generated m2m table (#11107).
+ """
+ out = StringIO()
+ management.call_command(
+ "dumpdata", "m2m_through_regress", format="json", stdout=out
+ )
+ self.assertJSONEqual(
+ out.getvalue().strip(),
+ '[{"pk": 1, "model": "m2m_through_regress.usermembership", '
+ '"fields": {"price": 100, "group": 1, "user": 1}}, '
+ '{"pk": 1, "model": "m2m_through_regress.person", '
+ '"fields": {"name": "Guido"}}, '
+ '{"pk": 1, "model": "m2m_through_regress.group", '
+ '"fields": {"name": "Python Core Group"}}]',
+ )
diff --git a/testbed/django__django/tests/m2o_recursive/__init__.py b/testbed/django__django/tests/m2o_recursive/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testbed/django__django/tests/m2o_recursive/models.py b/testbed/django__django/tests/m2o_recursive/models.py
new file mode 100644
index 0000000000000000000000000000000000000000..af235884563f13e79960e09ecefc1475d0384ef6
--- /dev/null
+++ b/testbed/django__django/tests/m2o_recursive/models.py
@@ -0,0 +1,36 @@
+"""
+Relating an object to itself, many-to-one
+
+To define a many-to-one relationship between a model and itself, use
+``ForeignKey('self', ...)``.
+
+In this example, a ``Category`` is related to itself. That is, each
+``Category`` has a parent ``Category``.
+
+Set ``related_name`` to designate what the reverse relationship is called.
+"""
+
+from django.db import models
+
+
+class Category(models.Model):
+ name = models.CharField(max_length=20)
+ parent = models.ForeignKey(
+ "self", models.SET_NULL, blank=True, null=True, related_name="child_set"
+ )
+
+ def __str__(self):
+ return self.name
+
+
+class Person(models.Model):
+ full_name = models.CharField(max_length=20)
+ mother = models.ForeignKey(
+ "self", models.SET_NULL, null=True, related_name="mothers_child_set"
+ )
+ father = models.ForeignKey(
+ "self", models.SET_NULL, null=True, related_name="fathers_child_set"
+ )
+
+ def __str__(self):
+ return self.full_name
diff --git a/testbed/django__django/tests/m2o_recursive/tests.py b/testbed/django__django/tests/m2o_recursive/tests.py
new file mode 100644
index 0000000000000000000000000000000000000000..ff68c60ee6dcc38458f9121baee566586f203b2b
--- /dev/null
+++ b/testbed/django__django/tests/m2o_recursive/tests.py
@@ -0,0 +1,39 @@
+from django.test import TestCase
+
+from .models import Category, Person
+
+
+class ManyToOneRecursiveTests(TestCase):
+ @classmethod
+ def setUpTestData(cls):
+ cls.r = Category.objects.create(id=None, name="Root category", parent=None)
+ cls.c = Category.objects.create(id=None, name="Child category", parent=cls.r)
+
+ def test_m2o_recursive(self):
+ self.assertSequenceEqual(self.r.child_set.all(), [self.c])
+ self.assertEqual(self.r.child_set.get(name__startswith="Child").id, self.c.id)
+ self.assertIsNone(self.r.parent)
+ self.assertSequenceEqual(self.c.child_set.all(), [])
+ self.assertEqual(self.c.parent.id, self.r.id)
+
+
+class MultipleManyToOneRecursiveTests(TestCase):
+ @classmethod
+ def setUpTestData(cls):
+ cls.dad = Person.objects.create(
+ full_name="John Smith Senior", mother=None, father=None
+ )
+ cls.mom = Person.objects.create(
+ full_name="Jane Smith", mother=None, father=None
+ )
+ cls.kid = Person.objects.create(
+ full_name="John Smith Junior", mother=cls.mom, father=cls.dad
+ )
+
+ def test_m2o_recursive2(self):
+ self.assertEqual(self.kid.mother.id, self.mom.id)
+ self.assertEqual(self.kid.father.id, self.dad.id)
+ self.assertSequenceEqual(self.dad.fathers_child_set.all(), [self.kid])
+ self.assertSequenceEqual(self.mom.mothers_child_set.all(), [self.kid])
+ self.assertSequenceEqual(self.kid.mothers_child_set.all(), [])
+ self.assertSequenceEqual(self.kid.fathers_child_set.all(), [])
diff --git a/testbed/django__django/tests/mail/__init__.py b/testbed/django__django/tests/mail/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testbed/django__django/tests/mail/attachments/file.eml b/testbed/django__django/tests/mail/attachments/file.eml
new file mode 100644
index 0000000000000000000000000000000000000000..b5b23c1be14368a9eb47fc2d9df25b8ba5ad4ae1
--- /dev/null
+++ b/testbed/django__django/tests/mail/attachments/file.eml
@@ -0,0 +1,44 @@
+MIME-Version: 1.0
+Received: by 10.220.191.194 with HTTP; Wed, 11 May 2011 12:27:12 -0700 (PDT)
+Date: Wed, 11 May 2011 13:27:12 -0600
+Delivered-To: jncjkq@gmail.com
+Message-ID:
+Subject: Test
+From: Bill Jncjkq
+To: bookmarks@jncjkq.net
+Content-Type: multipart/mixed; boundary=bcaec54eecc63acce904a3050f79
+
+--bcaec54eecc63acce904a3050f79
+Content-Type: multipart/alternative; boundary=bcaec54eecc63acce604a3050f77
+
+--bcaec54eecc63acce604a3050f77
+Content-Type: text/plain; charset=ISO-8859-1
+
+--
+Bill Jncjkq
+
+--bcaec54eecc63acce604a3050f77
+Content-Type: text/html; charset=ISO-8859-1
+
+
--
Bill Jncjkq
+
+--bcaec54eecc63acce604a3050f77--
+--bcaec54eecc63acce904a3050f79
+Content-Type: text/html; charset=US-ASCII; name="bookmarks-really-short.html"
+Content-Disposition: attachment; filename="bookmarks-really-short.html"
+Content-Transfer-Encoding: base64
+X-Attachment-Id: f_gnknv6u70
+
+PCFET0NUWVBFIE5FVFNDQVBFLUJvb2ttYXJrLWZpbGUtMT4KCTxIVE1MPgoJPE1FVEEgSFRUUC1F
+UVVJVj0iQ29udGVudC1UeXBlIiBDT05URU5UPSJ0ZXh0L2h0bWw7IGNoYXJzZXQ9VVRGLTgiPgoJ
+PFRpdGxlPkJvb2ttYXJrczwvVGl0bGU+Cgk8SDE+Qm9va21hcmtzPC9IMT4KCQk8RFQ+PEgzIEZP
+TERFRD5UZWNoIE5ld3M8L0gzPgoJCTxETD48cD4KCQkJPERUPjxBIEhSRUY9Imh0dHA6Ly93d3cu
+Y25ldC5jb20vIj5DTmV0PC9BPgoJCQk8RFQ+PEEgSFJFRj0iaHR0cDovL3d3dy53aXJlZC5jb20v
+Ij5XaXJlZCBOZXdzPC9BPgoJCTwvREw+PHA+CgkJPERUPjxIMyBGT0xERUQ+VG9vbHMgYW5kIFJl
+ZmVyZW5jZTwvSDM+CgkJPERMPjxwPgoJCQk8RFQ+PEEgSFJFRj0iaHR0cDovL3d3dy5tb25zdGVy
+LmNvbS8iPk1vbnN0ZXIuY29tPC9BPgoJCQk8RFQ+PEEgSFJFRj0iaHR0cDovL3d3dy53ZWJtZC5j
+b20vIj5XZWJNRDwvQT4KCQk8L0RMPjxwPgoJCTxEVD48SDMgRk9MREVEPlRyYXZlbDwvSDM+CgkJ
+PERMPjxwPgoJCQk8RFQ+PEEgSFJFRj0iaHR0cDovL2ZvZG9ycy5jb20vIj5Gb2RvcnM8L0E+CgkJ
+CTxEVD48QSBIUkVGPSJodHRwOi8vd3d3LnRyYXZlbG9jaXR5LmNvbS8iPlRyYXZlbG9jaXR5PC9B
+PgoJCTwvREw+PHA+Cgk8L0RMPjxwPgo8L0hUTUw+
+--bcaec54eecc63acce904a3050f79--
\ No newline at end of file
diff --git a/testbed/django__django/tests/mail/attachments/file.txt b/testbed/django__django/tests/mail/attachments/file.txt
new file mode 100644
index 0000000000000000000000000000000000000000..b884222da2bfa7c5a6cc59775700c87659e287f0
--- /dev/null
+++ b/testbed/django__django/tests/mail/attachments/file.txt
@@ -0,0 +1 @@
+django/django
\ No newline at end of file
diff --git a/testbed/django__django/tests/mail/attachments/file_png b/testbed/django__django/tests/mail/attachments/file_png
new file mode 100644
index 0000000000000000000000000000000000000000..85225ca1aea3cb54b23332754f6fd5b819397bf5
Binary files /dev/null and b/testbed/django__django/tests/mail/attachments/file_png differ
diff --git a/testbed/django__django/tests/mail/attachments/file_png.txt b/testbed/django__django/tests/mail/attachments/file_png.txt
new file mode 100644
index 0000000000000000000000000000000000000000..85225ca1aea3cb54b23332754f6fd5b819397bf5
Binary files /dev/null and b/testbed/django__django/tests/mail/attachments/file_png.txt differ
diff --git a/testbed/django__django/tests/mail/attachments/file_txt b/testbed/django__django/tests/mail/attachments/file_txt
new file mode 100644
index 0000000000000000000000000000000000000000..b884222da2bfa7c5a6cc59775700c87659e287f0
--- /dev/null
+++ b/testbed/django__django/tests/mail/attachments/file_txt
@@ -0,0 +1 @@
+django/django
\ No newline at end of file
diff --git a/testbed/django__django/tests/mail/custombackend.py b/testbed/django__django/tests/mail/custombackend.py
new file mode 100644
index 0000000000000000000000000000000000000000..14e7f077ba708e7b020dfb37a2af6517aec3f7d5
--- /dev/null
+++ b/testbed/django__django/tests/mail/custombackend.py
@@ -0,0 +1,14 @@
+"""A custom backend for testing."""
+
+from django.core.mail.backends.base import BaseEmailBackend
+
+
+class EmailBackend(BaseEmailBackend):
+ def __init__(self, *args, **kwargs):
+ super().__init__(*args, **kwargs)
+ self.test_outbox = []
+
+ def send_messages(self, email_messages):
+ # Messages are stored in an instance variable for testing.
+ self.test_outbox.extend(email_messages)
+ return len(email_messages)
diff --git a/testbed/django__django/tests/mail/test_sendtestemail.py b/testbed/django__django/tests/mail/test_sendtestemail.py
new file mode 100644
index 0000000000000000000000000000000000000000..8aff320568b07994933418434c18e8f66b088fe1
--- /dev/null
+++ b/testbed/django__django/tests/mail/test_sendtestemail.py
@@ -0,0 +1,103 @@
+from django.core import mail
+from django.core.management import call_command
+from django.test import SimpleTestCase, override_settings
+
+
+@override_settings(
+ ADMINS=(
+ ("Admin", "admin@example.com"),
+ ("Admin and Manager", "admin_and_manager@example.com"),
+ ),
+ MANAGERS=(
+ ("Manager", "manager@example.com"),
+ ("Admin and Manager", "admin_and_manager@example.com"),
+ ),
+)
+class SendTestEmailManagementCommand(SimpleTestCase):
+ """
+ Test the sending of a test email using the `sendtestemail` command.
+ """
+
+ def test_single_receiver(self):
+ """
+ The mail is sent with the correct subject and recipient.
+ """
+ recipient = "joe@example.com"
+ call_command("sendtestemail", recipient)
+ self.assertEqual(len(mail.outbox), 1)
+ mail_message = mail.outbox[0]
+ self.assertEqual(mail_message.subject[0:15], "Test email from")
+ self.assertEqual(mail_message.recipients(), [recipient])
+
+ def test_multiple_receivers(self):
+ """
+ The mail may be sent with multiple recipients.
+ """
+ recipients = ["joe@example.com", "jane@example.com"]
+ call_command("sendtestemail", recipients[0], recipients[1])
+ self.assertEqual(len(mail.outbox), 1)
+ mail_message = mail.outbox[0]
+ self.assertEqual(mail_message.subject[0:15], "Test email from")
+ self.assertEqual(
+ sorted(mail_message.recipients()),
+ [
+ "jane@example.com",
+ "joe@example.com",
+ ],
+ )
+
+ def test_manager_receivers(self):
+ """
+ The mail should be sent to the email addresses specified in
+ settings.MANAGERS.
+ """
+ call_command("sendtestemail", "--managers")
+ self.assertEqual(len(mail.outbox), 1)
+ mail_message = mail.outbox[0]
+ self.assertEqual(
+ sorted(mail_message.recipients()),
+ [
+ "admin_and_manager@example.com",
+ "manager@example.com",
+ ],
+ )
+
+ def test_admin_receivers(self):
+ """
+ The mail should be sent to the email addresses specified in
+ settings.ADMIN.
+ """
+ call_command("sendtestemail", "--admins")
+ self.assertEqual(len(mail.outbox), 1)
+ mail_message = mail.outbox[0]
+ self.assertEqual(
+ sorted(mail_message.recipients()),
+ [
+ "admin@example.com",
+ "admin_and_manager@example.com",
+ ],
+ )
+
+ def test_manager_and_admin_receivers(self):
+ """
+ The mail should be sent to the email addresses specified in both
+ settings.MANAGERS and settings.ADMINS.
+ """
+ call_command("sendtestemail", "--managers", "--admins")
+ self.assertEqual(len(mail.outbox), 2)
+ manager_mail = mail.outbox[0]
+ self.assertEqual(
+ sorted(manager_mail.recipients()),
+ [
+ "admin_and_manager@example.com",
+ "manager@example.com",
+ ],
+ )
+ admin_mail = mail.outbox[1]
+ self.assertEqual(
+ sorted(admin_mail.recipients()),
+ [
+ "admin@example.com",
+ "admin_and_manager@example.com",
+ ],
+ )
diff --git a/testbed/django__django/tests/mail/tests.py b/testbed/django__django/tests/mail/tests.py
new file mode 100644
index 0000000000000000000000000000000000000000..54a136c1a98b2d96880a232c961ab76855525420
--- /dev/null
+++ b/testbed/django__django/tests/mail/tests.py
@@ -0,0 +1,2008 @@
+import mimetypes
+import os
+import shutil
+import socket
+import sys
+import tempfile
+from email import charset, message_from_binary_file, message_from_bytes
+from email.header import Header
+from email.mime.text import MIMEText
+from email.utils import parseaddr
+from io import StringIO
+from pathlib import Path
+from smtplib import SMTP, SMTPException
+from ssl import SSLError
+from unittest import mock, skipUnless
+
+from django.core import mail
+from django.core.mail import (
+ DNS_NAME,
+ EmailMessage,
+ EmailMultiAlternatives,
+ mail_admins,
+ mail_managers,
+ send_mail,
+ send_mass_mail,
+)
+from django.core.mail.backends import console, dummy, filebased, locmem, smtp
+from django.core.mail.message import BadHeaderError, sanitize_address
+from django.test import SimpleTestCase, override_settings
+from django.test.utils import requires_tz_support
+from django.utils.translation import gettext_lazy
+from django.utils.version import PY311
+
+try:
+ from aiosmtpd.controller import Controller
+
+ HAS_AIOSMTPD = True
+except ImportError:
+ HAS_AIOSMTPD = False
+
+
+class HeadersCheckMixin:
+ def assertMessageHasHeaders(self, message, headers):
+ """
+ Asserts that the `message` has all `headers`.
+
+ message: can be an instance of an email.Message subclass or a string
+ with the contents of an email message.
+ headers: should be a set of (header-name, header-value) tuples.
+ """
+ if isinstance(message, bytes):
+ message = message_from_bytes(message)
+ msg_headers = set(message.items())
+ self.assertTrue(
+ headers.issubset(msg_headers),
+ msg="Message is missing "
+ "the following headers: %s" % (headers - msg_headers),
+ )
+
+
+class MailTests(HeadersCheckMixin, SimpleTestCase):
+ """
+ Non-backend specific tests.
+ """
+
+ def get_decoded_attachments(self, django_message):
+ """
+ Encode the specified django.core.mail.message.EmailMessage, then decode
+ it using Python's email.parser module and, for each attachment of the
+ message, return a list of tuples with (filename, content, mimetype).
+ """
+ msg_bytes = django_message.message().as_bytes()
+ email_message = message_from_bytes(msg_bytes)
+
+ def iter_attachments():
+ for i in email_message.walk():
+ if i.get_content_disposition() == "attachment":
+ filename = i.get_filename()
+ content = i.get_payload(decode=True)
+ mimetype = i.get_content_type()
+ yield filename, content, mimetype
+
+ return list(iter_attachments())
+
+ def test_ascii(self):
+ email = EmailMessage(
+ "Subject", "Content", "from@example.com", ["to@example.com"]
+ )
+ message = email.message()
+ self.assertEqual(message["Subject"], "Subject")
+ self.assertEqual(message.get_payload(), "Content")
+ self.assertEqual(message["From"], "from@example.com")
+ self.assertEqual(message["To"], "to@example.com")
+
+ def test_multiple_recipients(self):
+ email = EmailMessage(
+ "Subject",
+ "Content",
+ "from@example.com",
+ ["to@example.com", "other@example.com"],
+ )
+ message = email.message()
+ self.assertEqual(message["Subject"], "Subject")
+ self.assertEqual(message.get_payload(), "Content")
+ self.assertEqual(message["From"], "from@example.com")
+ self.assertEqual(message["To"], "to@example.com, other@example.com")
+
+ def test_header_omitted_for_no_to_recipients(self):
+ message = EmailMessage(
+ "Subject", "Content", "from@example.com", cc=["cc@example.com"]
+ ).message()
+ self.assertNotIn("To", message)
+
+ def test_recipients_with_empty_strings(self):
+ """
+ Empty strings in various recipient arguments are always stripped
+ off the final recipient list.
+ """
+ email = EmailMessage(
+ "Subject",
+ "Content",
+ "from@example.com",
+ ["to@example.com", ""],
+ cc=["cc@example.com", ""],
+ bcc=["", "bcc@example.com"],
+ reply_to=["", None],
+ )
+ self.assertEqual(
+ email.recipients(), ["to@example.com", "cc@example.com", "bcc@example.com"]
+ )
+
+ def test_cc(self):
+ """Regression test for #7722"""
+ email = EmailMessage(
+ "Subject",
+ "Content",
+ "from@example.com",
+ ["to@example.com"],
+ cc=["cc@example.com"],
+ )
+ message = email.message()
+ self.assertEqual(message["Cc"], "cc@example.com")
+ self.assertEqual(email.recipients(), ["to@example.com", "cc@example.com"])
+
+ # Test multiple CC with multiple To
+ email = EmailMessage(
+ "Subject",
+ "Content",
+ "from@example.com",
+ ["to@example.com", "other@example.com"],
+ cc=["cc@example.com", "cc.other@example.com"],
+ )
+ message = email.message()
+ self.assertEqual(message["Cc"], "cc@example.com, cc.other@example.com")
+ self.assertEqual(
+ email.recipients(),
+ [
+ "to@example.com",
+ "other@example.com",
+ "cc@example.com",
+ "cc.other@example.com",
+ ],
+ )
+
+ # Testing with Bcc
+ email = EmailMessage(
+ "Subject",
+ "Content",
+ "from@example.com",
+ ["to@example.com", "other@example.com"],
+ cc=["cc@example.com", "cc.other@example.com"],
+ bcc=["bcc@example.com"],
+ )
+ message = email.message()
+ self.assertEqual(message["Cc"], "cc@example.com, cc.other@example.com")
+ self.assertEqual(
+ email.recipients(),
+ [
+ "to@example.com",
+ "other@example.com",
+ "cc@example.com",
+ "cc.other@example.com",
+ "bcc@example.com",
+ ],
+ )
+
+ def test_cc_headers(self):
+ message = EmailMessage(
+ "Subject",
+ "Content",
+ "bounce@example.com",
+ ["to@example.com"],
+ cc=["foo@example.com"],
+ headers={"Cc": "override@example.com"},
+ ).message()
+ self.assertEqual(message["Cc"], "override@example.com")
+
+ def test_cc_in_headers_only(self):
+ message = EmailMessage(
+ "Subject",
+ "Content",
+ "bounce@example.com",
+ ["to@example.com"],
+ headers={"Cc": "foo@example.com"},
+ ).message()
+ self.assertEqual(message["Cc"], "foo@example.com")
+
+ def test_reply_to(self):
+ email = EmailMessage(
+ "Subject",
+ "Content",
+ "from@example.com",
+ ["to@example.com"],
+ reply_to=["reply_to@example.com"],
+ )
+ message = email.message()
+ self.assertEqual(message["Reply-To"], "reply_to@example.com")
+
+ email = EmailMessage(
+ "Subject",
+ "Content",
+ "from@example.com",
+ ["to@example.com"],
+ reply_to=["reply_to1@example.com", "reply_to2@example.com"],
+ )
+ message = email.message()
+ self.assertEqual(
+ message["Reply-To"], "reply_to1@example.com, reply_to2@example.com"
+ )
+
+ def test_recipients_as_tuple(self):
+ email = EmailMessage(
+ "Subject",
+ "Content",
+ "from@example.com",
+ ("to@example.com", "other@example.com"),
+ cc=("cc@example.com", "cc.other@example.com"),
+ bcc=("bcc@example.com",),
+ )
+ message = email.message()
+ self.assertEqual(message["Cc"], "cc@example.com, cc.other@example.com")
+ self.assertEqual(
+ email.recipients(),
+ [
+ "to@example.com",
+ "other@example.com",
+ "cc@example.com",
+ "cc.other@example.com",
+ "bcc@example.com",
+ ],
+ )
+
+ def test_recipients_as_string(self):
+ with self.assertRaisesMessage(
+ TypeError, '"to" argument must be a list or tuple'
+ ):
+ EmailMessage(to="foo@example.com")
+ with self.assertRaisesMessage(
+ TypeError, '"cc" argument must be a list or tuple'
+ ):
+ EmailMessage(cc="foo@example.com")
+ with self.assertRaisesMessage(
+ TypeError, '"bcc" argument must be a list or tuple'
+ ):
+ EmailMessage(bcc="foo@example.com")
+ with self.assertRaisesMessage(
+ TypeError, '"reply_to" argument must be a list or tuple'
+ ):
+ EmailMessage(reply_to="reply_to@example.com")
+
+ def test_header_injection(self):
+ msg = "Header values can't contain newlines "
+ email = EmailMessage(
+ "Subject\nInjection Test", "Content", "from@example.com", ["to@example.com"]
+ )
+ with self.assertRaisesMessage(BadHeaderError, msg):
+ email.message()
+ email = EmailMessage(
+ gettext_lazy("Subject\nInjection Test"),
+ "Content",
+ "from@example.com",
+ ["to@example.com"],
+ )
+ with self.assertRaisesMessage(BadHeaderError, msg):
+ email.message()
+ with self.assertRaisesMessage(BadHeaderError, msg):
+ EmailMessage(
+ "Subject",
+ "Content",
+ "from@example.com",
+ ["Name\nInjection test "],
+ ).message()
+
+ def test_space_continuation(self):
+ """
+ Test for space continuation character in long (ASCII) subject headers (#7747)
+ """
+ email = EmailMessage(
+ "Long subject lines that get wrapped should contain a space continuation "
+ "character to get expected behavior in Outlook and Thunderbird",
+ "Content",
+ "from@example.com",
+ ["to@example.com"],
+ )
+ message = email.message()
+ self.assertEqual(
+ message["Subject"].encode(),
+ b"Long subject lines that get wrapped should contain a space continuation\n"
+ b" character to get expected behavior in Outlook and Thunderbird",
+ )
+
+ def test_message_header_overrides(self):
+ """
+ Specifying dates or message-ids in the extra headers overrides the
+ default values (#9233)
+ """
+ headers = {"date": "Fri, 09 Nov 2001 01:08:47 -0000", "Message-ID": "foo"}
+ email = EmailMessage(
+ "subject",
+ "content",
+ "from@example.com",
+ ["to@example.com"],
+ headers=headers,
+ )
+
+ self.assertMessageHasHeaders(
+ email.message(),
+ {
+ ("Content-Transfer-Encoding", "7bit"),
+ ("Content-Type", 'text/plain; charset="utf-8"'),
+ ("From", "from@example.com"),
+ ("MIME-Version", "1.0"),
+ ("Message-ID", "foo"),
+ ("Subject", "subject"),
+ ("To", "to@example.com"),
+ ("date", "Fri, 09 Nov 2001 01:08:47 -0000"),
+ },
+ )
+
+ def test_from_header(self):
+ """
+ Make sure we can manually set the From header (#9214)
+ """
+ email = EmailMessage(
+ "Subject",
+ "Content",
+ "bounce@example.com",
+ ["to@example.com"],
+ headers={"From": "from@example.com"},
+ )
+ message = email.message()
+ self.assertEqual(message["From"], "from@example.com")
+
+ def test_to_header(self):
+ """
+ Make sure we can manually set the To header (#17444)
+ """
+ email = EmailMessage(
+ "Subject",
+ "Content",
+ "bounce@example.com",
+ ["list-subscriber@example.com", "list-subscriber2@example.com"],
+ headers={"To": "mailing-list@example.com"},
+ )
+ message = email.message()
+ self.assertEqual(message["To"], "mailing-list@example.com")
+ self.assertEqual(
+ email.to, ["list-subscriber@example.com", "list-subscriber2@example.com"]
+ )
+
+ # If we don't set the To header manually, it should default to the `to`
+ # argument to the constructor.
+ email = EmailMessage(
+ "Subject",
+ "Content",
+ "bounce@example.com",
+ ["list-subscriber@example.com", "list-subscriber2@example.com"],
+ )
+ message = email.message()
+ self.assertEqual(
+ message["To"], "list-subscriber@example.com, list-subscriber2@example.com"
+ )
+ self.assertEqual(
+ email.to, ["list-subscriber@example.com", "list-subscriber2@example.com"]
+ )
+
+ def test_to_in_headers_only(self):
+ message = EmailMessage(
+ "Subject",
+ "Content",
+ "bounce@example.com",
+ headers={"To": "to@example.com"},
+ ).message()
+ self.assertEqual(message["To"], "to@example.com")
+
+ def test_reply_to_header(self):
+ """
+ Specifying 'Reply-To' in headers should override reply_to.
+ """
+ email = EmailMessage(
+ "Subject",
+ "Content",
+ "bounce@example.com",
+ ["to@example.com"],
+ reply_to=["foo@example.com"],
+ headers={"Reply-To": "override@example.com"},
+ )
+ message = email.message()
+ self.assertEqual(message["Reply-To"], "override@example.com")
+
+ def test_reply_to_in_headers_only(self):
+ message = EmailMessage(
+ "Subject",
+ "Content",
+ "from@example.com",
+ ["to@example.com"],
+ headers={"Reply-To": "reply_to@example.com"},
+ ).message()
+ self.assertEqual(message["Reply-To"], "reply_to@example.com")
+
+ def test_multiple_message_call(self):
+ """
+ Regression for #13259 - Make sure that headers are not changed when
+ calling EmailMessage.message()
+ """
+ email = EmailMessage(
+ "Subject",
+ "Content",
+ "bounce@example.com",
+ ["to@example.com"],
+ headers={"From": "from@example.com"},
+ )
+ message = email.message()
+ self.assertEqual(message["From"], "from@example.com")
+ message = email.message()
+ self.assertEqual(message["From"], "from@example.com")
+
+ def test_unicode_address_header(self):
+ """
+ Regression for #11144 - When a to/from/cc header contains Unicode,
+ make sure the email addresses are parsed correctly (especially with
+ regards to commas)
+ """
+ email = EmailMessage(
+ "Subject",
+ "Content",
+ "from@example.com",
+ ['"Firstname Sürname" ', "other@example.com"],
+ )
+ self.assertEqual(
+ email.message()["To"],
+ "=?utf-8?q?Firstname_S=C3=BCrname?= , other@example.com",
+ )
+ email = EmailMessage(
+ "Subject",
+ "Content",
+ "from@example.com",
+ ['"Sürname, Firstname" ', "other@example.com"],
+ )
+ self.assertEqual(
+ email.message()["To"],
+ "=?utf-8?q?S=C3=BCrname=2C_Firstname?= , other@example.com",
+ )
+
+ def test_unicode_headers(self):
+ email = EmailMessage(
+ "Gżegżółka",
+ "Content",
+ "from@example.com",
+ ["to@example.com"],
+ headers={
+ "Sender": '"Firstname Sürname" ',
+ "Comments": "My Sürname is non-ASCII",
+ },
+ )
+ message = email.message()
+ self.assertEqual(message["Subject"], "=?utf-8?b?R8W8ZWfFvMOzxYJrYQ==?=")
+ self.assertEqual(
+ message["Sender"], "=?utf-8?q?Firstname_S=C3=BCrname?= "
+ )
+ self.assertEqual(
+ message["Comments"], "=?utf-8?q?My_S=C3=BCrname_is_non-ASCII?="
+ )
+
+ def test_safe_mime_multipart(self):
+ """
+ Make sure headers can be set with a different encoding than utf-8 in
+ SafeMIMEMultipart as well
+ """
+ headers = {"Date": "Fri, 09 Nov 2001 01:08:47 -0000", "Message-ID": "foo"}
+ from_email, to = "from@example.com", '"Sürname, Firstname" '
+ text_content = "This is an important message."
+ html_content = "This is an important message.
"
+ msg = EmailMultiAlternatives(
+ "Message from Firstname Sürname",
+ text_content,
+ from_email,
+ [to],
+ headers=headers,
+ )
+ msg.attach_alternative(html_content, "text/html")
+ msg.encoding = "iso-8859-1"
+ self.assertEqual(
+ msg.message()["To"],
+ "=?iso-8859-1?q?S=FCrname=2C_Firstname?= ",
+ )
+ self.assertEqual(
+ msg.message()["Subject"],
+ "=?iso-8859-1?q?Message_from_Firstname_S=FCrname?=",
+ )
+
+ def test_safe_mime_multipart_with_attachments(self):
+ """
+ EmailMultiAlternatives includes alternatives if the body is empty and
+ it has attachments.
+ """
+ msg = EmailMultiAlternatives(body="")
+ html_content = "This is html
"
+ msg.attach_alternative(html_content, "text/html")
+ msg.attach("example.txt", "Text file content", "text/plain")
+ self.assertIn(html_content, msg.message().as_string())
+
+ def test_none_body(self):
+ msg = EmailMessage("subject", None, "from@example.com", ["to@example.com"])
+ self.assertEqual(msg.body, "")
+ self.assertEqual(msg.message().get_payload(), "")
+
+ @mock.patch("socket.getfqdn", return_value="漢字")
+ def test_non_ascii_dns_non_unicode_email(self, mocked_getfqdn):
+ delattr(DNS_NAME, "_fqdn")
+ email = EmailMessage(
+ "subject", "content", "from@example.com", ["to@example.com"]
+ )
+ email.encoding = "iso-8859-1"
+ self.assertIn("@xn--p8s937b>", email.message()["Message-ID"])
+
+ def test_encoding(self):
+ """
+ Regression for #12791 - Encode body correctly with other encodings
+ than utf-8
+ """
+ email = EmailMessage(
+ "Subject",
+ "Firstname Sürname is a great guy.",
+ "from@example.com",
+ ["other@example.com"],
+ )
+ email.encoding = "iso-8859-1"
+ message = email.message()
+ self.assertMessageHasHeaders(
+ message,
+ {
+ ("MIME-Version", "1.0"),
+ ("Content-Type", 'text/plain; charset="iso-8859-1"'),
+ ("Content-Transfer-Encoding", "quoted-printable"),
+ ("Subject", "Subject"),
+ ("From", "from@example.com"),
+ ("To", "other@example.com"),
+ },
+ )
+ self.assertEqual(message.get_payload(), "Firstname S=FCrname is a great guy.")
+
+ # MIME attachments works correctly with other encodings than utf-8.
+ text_content = "Firstname Sürname is a great guy."
+ html_content = "Firstname Sürname is a great guy.
"
+ msg = EmailMultiAlternatives(
+ "Subject", text_content, "from@example.com", ["to@example.com"]
+ )
+ msg.encoding = "iso-8859-1"
+ msg.attach_alternative(html_content, "text/html")
+ payload0 = msg.message().get_payload(0)
+ self.assertMessageHasHeaders(
+ payload0,
+ {
+ ("MIME-Version", "1.0"),
+ ("Content-Type", 'text/plain; charset="iso-8859-1"'),
+ ("Content-Transfer-Encoding", "quoted-printable"),
+ },
+ )
+ self.assertTrue(
+ payload0.as_bytes().endswith(b"\n\nFirstname S=FCrname is a great guy.")
+ )
+ payload1 = msg.message().get_payload(1)
+ self.assertMessageHasHeaders(
+ payload1,
+ {
+ ("MIME-Version", "1.0"),
+ ("Content-Type", 'text/html; charset="iso-8859-1"'),
+ ("Content-Transfer-Encoding", "quoted-printable"),
+ },
+ )
+ self.assertTrue(
+ payload1.as_bytes().endswith(
+ b"\n\nFirstname S=FCrname is a great guy.
"
+ )
+ )
+
+ def test_attachments(self):
+ """Regression test for #9367"""
+ headers = {"Date": "Fri, 09 Nov 2001 01:08:47 -0000", "Message-ID": "foo"}
+ subject, from_email, to = "hello", "from@example.com", "to@example.com"
+ text_content = "This is an important message."
+ html_content = "This is an important message.
"
+ msg = EmailMultiAlternatives(
+ subject, text_content, from_email, [to], headers=headers
+ )
+ msg.attach_alternative(html_content, "text/html")
+ msg.attach("an attachment.pdf", b"%PDF-1.4.%...", mimetype="application/pdf")
+ msg_bytes = msg.message().as_bytes()
+ message = message_from_bytes(msg_bytes)
+ self.assertTrue(message.is_multipart())
+ self.assertEqual(message.get_content_type(), "multipart/mixed")
+ self.assertEqual(message.get_default_type(), "text/plain")
+ payload = message.get_payload()
+ self.assertEqual(payload[0].get_content_type(), "multipart/alternative")
+ self.assertEqual(payload[1].get_content_type(), "application/pdf")
+
+ def test_attachments_two_tuple(self):
+ msg = EmailMessage(attachments=[("filename1", "content1")])
+ filename, content, mimetype = self.get_decoded_attachments(msg)[0]
+ self.assertEqual(filename, "filename1")
+ self.assertEqual(content, b"content1")
+ self.assertEqual(mimetype, "application/octet-stream")
+
+ def test_attachments_MIMEText(self):
+ txt = MIMEText("content1")
+ msg = EmailMessage(attachments=[txt])
+ payload = msg.message().get_payload()
+ self.assertEqual(payload[0], txt)
+
+ def test_non_ascii_attachment_filename(self):
+ """Regression test for #14964"""
+ headers = {"Date": "Fri, 09 Nov 2001 01:08:47 -0000", "Message-ID": "foo"}
+ subject, from_email, to = "hello", "from@example.com", "to@example.com"
+ content = "This is the message."
+ msg = EmailMessage(subject, content, from_email, [to], headers=headers)
+ # Unicode in file name
+ msg.attach("une pièce jointe.pdf", b"%PDF-1.4.%...", mimetype="application/pdf")
+ msg_bytes = msg.message().as_bytes()
+ message = message_from_bytes(msg_bytes)
+ payload = message.get_payload()
+ self.assertEqual(payload[1].get_filename(), "une pièce jointe.pdf")
+
+ def test_attach_file(self):
+ """
+ Test attaching a file against different mimetypes and make sure that
+ a file will be attached and sent properly even if an invalid mimetype
+ is specified.
+ """
+ files = (
+ # filename, actual mimetype
+ ("file.txt", "text/plain"),
+ ("file.png", "image/png"),
+ ("file_txt", None),
+ ("file_png", None),
+ ("file_txt.png", "image/png"),
+ ("file_png.txt", "text/plain"),
+ ("file.eml", "message/rfc822"),
+ )
+ test_mimetypes = ["text/plain", "image/png", None]
+
+ for basename, real_mimetype in files:
+ for mimetype in test_mimetypes:
+ email = EmailMessage(
+ "subject", "body", "from@example.com", ["to@example.com"]
+ )
+ self.assertEqual(mimetypes.guess_type(basename)[0], real_mimetype)
+ self.assertEqual(email.attachments, [])
+ file_path = os.path.join(
+ os.path.dirname(__file__), "attachments", basename
+ )
+ email.attach_file(file_path, mimetype=mimetype)
+ self.assertEqual(len(email.attachments), 1)
+ self.assertIn(basename, email.attachments[0])
+ msgs_sent_num = email.send()
+ self.assertEqual(msgs_sent_num, 1)
+
+ def test_attach_text_as_bytes(self):
+ msg = EmailMessage("subject", "body", "from@example.com", ["to@example.com"])
+ msg.attach("file.txt", b"file content")
+ sent_num = msg.send()
+ self.assertEqual(sent_num, 1)
+ filename, content, mimetype = self.get_decoded_attachments(msg)[0]
+ self.assertEqual(filename, "file.txt")
+ self.assertEqual(content, b"file content")
+ self.assertEqual(mimetype, "text/plain")
+
+ def test_attach_utf8_text_as_bytes(self):
+ """
+ Non-ASCII characters encoded as valid UTF-8 are correctly transported
+ and decoded.
+ """
+ msg = EmailMessage("subject", "body", "from@example.com", ["to@example.com"])
+ msg.attach("file.txt", b"\xc3\xa4") # UTF-8 encoded a umlaut.
+ filename, content, mimetype = self.get_decoded_attachments(msg)[0]
+ self.assertEqual(filename, "file.txt")
+ self.assertEqual(content, b"\xc3\xa4")
+ self.assertEqual(mimetype, "text/plain")
+
+ def test_attach_non_utf8_text_as_bytes(self):
+ """
+ Binary data that can't be decoded as UTF-8 overrides the MIME type
+ instead of decoding the data.
+ """
+ msg = EmailMessage("subject", "body", "from@example.com", ["to@example.com"])
+ msg.attach("file.txt", b"\xff") # Invalid UTF-8.
+ filename, content, mimetype = self.get_decoded_attachments(msg)[0]
+ self.assertEqual(filename, "file.txt")
+ # Content should be passed through unmodified.
+ self.assertEqual(content, b"\xff")
+ self.assertEqual(mimetype, "application/octet-stream")
+
+ def test_attach_mimetext_content_mimetype(self):
+ email_msg = EmailMessage()
+ txt = MIMEText("content")
+ msg = (
+ "content and mimetype must not be given when a MIMEBase instance "
+ "is provided."
+ )
+ with self.assertRaisesMessage(ValueError, msg):
+ email_msg.attach(txt, content="content")
+ with self.assertRaisesMessage(ValueError, msg):
+ email_msg.attach(txt, mimetype="text/plain")
+
+ def test_attach_content_none(self):
+ email_msg = EmailMessage()
+ msg = "content must be provided."
+ with self.assertRaisesMessage(ValueError, msg):
+ email_msg.attach("file.txt", mimetype="application/pdf")
+
+ def test_dummy_backend(self):
+ """
+ Make sure that dummy backends returns correct number of sent messages
+ """
+ connection = dummy.EmailBackend()
+ email = EmailMessage(
+ "Subject",
+ "Content",
+ "bounce@example.com",
+ ["to@example.com"],
+ headers={"From": "from@example.com"},
+ )
+ self.assertEqual(connection.send_messages([email, email, email]), 3)
+
+ def test_arbitrary_keyword(self):
+ """
+ Make sure that get_connection() accepts arbitrary keyword that might be
+ used with custom backends.
+ """
+ c = mail.get_connection(fail_silently=True, foo="bar")
+ self.assertTrue(c.fail_silently)
+
+ def test_custom_backend(self):
+ """Test custom backend defined in this suite."""
+ conn = mail.get_connection("mail.custombackend.EmailBackend")
+ self.assertTrue(hasattr(conn, "test_outbox"))
+ email = EmailMessage(
+ "Subject",
+ "Content",
+ "bounce@example.com",
+ ["to@example.com"],
+ headers={"From": "from@example.com"},
+ )
+ conn.send_messages([email])
+ self.assertEqual(len(conn.test_outbox), 1)
+
+ def test_backend_arg(self):
+ """Test backend argument of mail.get_connection()"""
+ self.assertIsInstance(
+ mail.get_connection("django.core.mail.backends.smtp.EmailBackend"),
+ smtp.EmailBackend,
+ )
+ self.assertIsInstance(
+ mail.get_connection("django.core.mail.backends.locmem.EmailBackend"),
+ locmem.EmailBackend,
+ )
+ self.assertIsInstance(
+ mail.get_connection("django.core.mail.backends.dummy.EmailBackend"),
+ dummy.EmailBackend,
+ )
+ self.assertIsInstance(
+ mail.get_connection("django.core.mail.backends.console.EmailBackend"),
+ console.EmailBackend,
+ )
+ with tempfile.TemporaryDirectory() as tmp_dir:
+ self.assertIsInstance(
+ mail.get_connection(
+ "django.core.mail.backends.filebased.EmailBackend",
+ file_path=tmp_dir,
+ ),
+ filebased.EmailBackend,
+ )
+
+ if sys.platform == "win32" and not PY311:
+ msg = (
+ "_getfullpathname: path should be string, bytes or os.PathLike, not "
+ "object"
+ )
+ else:
+ msg = "expected str, bytes or os.PathLike object, not object"
+ with self.assertRaisesMessage(TypeError, msg):
+ mail.get_connection(
+ "django.core.mail.backends.filebased.EmailBackend", file_path=object()
+ )
+ self.assertIsInstance(mail.get_connection(), locmem.EmailBackend)
+
+ @override_settings(
+ EMAIL_BACKEND="django.core.mail.backends.locmem.EmailBackend",
+ ADMINS=[("nobody", "nobody@example.com")],
+ MANAGERS=[("nobody", "nobody@example.com")],
+ )
+ def test_connection_arg(self):
+ """Test connection argument to send_mail(), et. al."""
+ mail.outbox = []
+
+ # Send using non-default connection
+ connection = mail.get_connection("mail.custombackend.EmailBackend")
+ send_mail(
+ "Subject",
+ "Content",
+ "from@example.com",
+ ["to@example.com"],
+ connection=connection,
+ )
+ self.assertEqual(mail.outbox, [])
+ self.assertEqual(len(connection.test_outbox), 1)
+ self.assertEqual(connection.test_outbox[0].subject, "Subject")
+
+ connection = mail.get_connection("mail.custombackend.EmailBackend")
+ send_mass_mail(
+ [
+ ("Subject1", "Content1", "from1@example.com", ["to1@example.com"]),
+ ("Subject2", "Content2", "from2@example.com", ["to2@example.com"]),
+ ],
+ connection=connection,
+ )
+ self.assertEqual(mail.outbox, [])
+ self.assertEqual(len(connection.test_outbox), 2)
+ self.assertEqual(connection.test_outbox[0].subject, "Subject1")
+ self.assertEqual(connection.test_outbox[1].subject, "Subject2")
+
+ connection = mail.get_connection("mail.custombackend.EmailBackend")
+ mail_admins("Admin message", "Content", connection=connection)
+ self.assertEqual(mail.outbox, [])
+ self.assertEqual(len(connection.test_outbox), 1)
+ self.assertEqual(connection.test_outbox[0].subject, "[Django] Admin message")
+
+ connection = mail.get_connection("mail.custombackend.EmailBackend")
+ mail_managers("Manager message", "Content", connection=connection)
+ self.assertEqual(mail.outbox, [])
+ self.assertEqual(len(connection.test_outbox), 1)
+ self.assertEqual(connection.test_outbox[0].subject, "[Django] Manager message")
+
+ def test_dont_mangle_from_in_body(self):
+ # Regression for #13433 - Make sure that EmailMessage doesn't mangle
+ # 'From ' in message body.
+ email = EmailMessage(
+ "Subject",
+ "From the future",
+ "bounce@example.com",
+ ["to@example.com"],
+ headers={"From": "from@example.com"},
+ )
+ self.assertNotIn(b">From the future", email.message().as_bytes())
+
+ def test_dont_base64_encode(self):
+ # Ticket #3472
+ # Shouldn't use Base64 encoding at all
+ msg = EmailMessage(
+ "Subject",
+ "UTF-8 encoded body",
+ "bounce@example.com",
+ ["to@example.com"],
+ headers={"From": "from@example.com"},
+ )
+ self.assertIn(b"Content-Transfer-Encoding: 7bit", msg.message().as_bytes())
+
+ # Ticket #11212
+ # Shouldn't use quoted printable, should detect it can represent
+ # content with 7 bit data.
+ msg = EmailMessage(
+ "Subject",
+ "Body with only ASCII characters.",
+ "bounce@example.com",
+ ["to@example.com"],
+ headers={"From": "from@example.com"},
+ )
+ s = msg.message().as_bytes()
+ self.assertIn(b"Content-Transfer-Encoding: 7bit", s)
+
+ # Shouldn't use quoted printable, should detect it can represent
+ # content with 8 bit data.
+ msg = EmailMessage(
+ "Subject",
+ "Body with latin characters: àáä.",
+ "bounce@example.com",
+ ["to@example.com"],
+ headers={"From": "from@example.com"},
+ )
+ s = msg.message().as_bytes()
+ self.assertIn(b"Content-Transfer-Encoding: 8bit", s)
+ s = msg.message().as_string()
+ self.assertIn("Content-Transfer-Encoding: 8bit", s)
+
+ msg = EmailMessage(
+ "Subject",
+ "Body with non latin characters: А Б В Г Д Е Ж Ѕ З И І К Л М Н О П.",
+ "bounce@example.com",
+ ["to@example.com"],
+ headers={"From": "from@example.com"},
+ )
+ s = msg.message().as_bytes()
+ self.assertIn(b"Content-Transfer-Encoding: 8bit", s)
+ s = msg.message().as_string()
+ self.assertIn("Content-Transfer-Encoding: 8bit", s)
+
+ def test_dont_base64_encode_message_rfc822(self):
+ # Ticket #18967
+ # Shouldn't use base64 encoding for a child EmailMessage attachment.
+ # Create a child message first
+ child_msg = EmailMessage(
+ "Child Subject",
+ "Some body of child message",
+ "bounce@example.com",
+ ["to@example.com"],
+ headers={"From": "from@example.com"},
+ )
+ child_s = child_msg.message().as_string()
+
+ # Now create a parent
+ parent_msg = EmailMessage(
+ "Parent Subject",
+ "Some parent body",
+ "bounce@example.com",
+ ["to@example.com"],
+ headers={"From": "from@example.com"},
+ )
+
+ # Attach to parent as a string
+ parent_msg.attach(content=child_s, mimetype="message/rfc822")
+ parent_s = parent_msg.message().as_string()
+
+ # The child message header is not base64 encoded
+ self.assertIn("Child Subject", parent_s)
+
+ # Feature test: try attaching email.Message object directly to the mail.
+ parent_msg = EmailMessage(
+ "Parent Subject",
+ "Some parent body",
+ "bounce@example.com",
+ ["to@example.com"],
+ headers={"From": "from@example.com"},
+ )
+ parent_msg.attach(content=child_msg.message(), mimetype="message/rfc822")
+ parent_s = parent_msg.message().as_string()
+
+ # The child message header is not base64 encoded
+ self.assertIn("Child Subject", parent_s)
+
+ # Feature test: try attaching Django's EmailMessage object directly to the mail.
+ parent_msg = EmailMessage(
+ "Parent Subject",
+ "Some parent body",
+ "bounce@example.com",
+ ["to@example.com"],
+ headers={"From": "from@example.com"},
+ )
+ parent_msg.attach(content=child_msg, mimetype="message/rfc822")
+ parent_s = parent_msg.message().as_string()
+
+ # The child message header is not base64 encoded
+ self.assertIn("Child Subject", parent_s)
+
+ def test_custom_utf8_encoding(self):
+ """A UTF-8 charset with a custom body encoding is respected."""
+ body = "Body with latin characters: àáä."
+ msg = EmailMessage("Subject", body, "bounce@example.com", ["to@example.com"])
+ encoding = charset.Charset("utf-8")
+ encoding.body_encoding = charset.QP
+ msg.encoding = encoding
+ message = msg.message()
+ self.assertMessageHasHeaders(
+ message,
+ {
+ ("MIME-Version", "1.0"),
+ ("Content-Type", 'text/plain; charset="utf-8"'),
+ ("Content-Transfer-Encoding", "quoted-printable"),
+ },
+ )
+ self.assertEqual(message.get_payload(), encoding.body_encode(body))
+
+ def test_sanitize_address(self):
+ """Email addresses are properly sanitized."""
+ for email_address, encoding, expected_result in (
+ # ASCII addresses.
+ ("to@example.com", "ascii", "to@example.com"),
+ ("to@example.com", "utf-8", "to@example.com"),
+ (("A name", "to@example.com"), "ascii", "A name "),
+ (
+ ("A name", "to@example.com"),
+ "utf-8",
+ "A name ",
+ ),
+ ("localpartonly", "ascii", "localpartonly"),
+ # ASCII addresses with display names.
+ ("A name ", "ascii", "A name "),
+ ("A name ", "utf-8", "A name "),
+ ('"A name" ', "ascii", "A name "),
+ ('"A name" ', "utf-8", "A name "),
+ # Unicode addresses (supported per RFC-6532).
+ ("tó@example.com", "utf-8", "=?utf-8?b?dMOz?=@example.com"),
+ ("to@éxample.com", "utf-8", "to@xn--xample-9ua.com"),
+ (
+ ("Tó Example", "tó@example.com"),
+ "utf-8",
+ "=?utf-8?q?T=C3=B3_Example?= <=?utf-8?b?dMOz?=@example.com>",
+ ),
+ # Unicode addresses with display names.
+ (
+ "Tó Example ",
+ "utf-8",
+ "=?utf-8?q?T=C3=B3_Example?= <=?utf-8?b?dMOz?=@example.com>",
+ ),
+ (
+ "To Example ",
+ "ascii",
+ "To Example ",
+ ),
+ (
+ "To Example ",
+ "utf-8",
+ "To Example ",
+ ),
+ # Addresses with two @ signs.
+ ('"to@other.com"@example.com', "utf-8", r'"to@other.com"@example.com'),
+ (
+ '"to@other.com" ',
+ "utf-8",
+ '"to@other.com" ',
+ ),
+ (
+ ("To Example", "to@other.com@example.com"),
+ "utf-8",
+ 'To Example <"to@other.com"@example.com>',
+ ),
+ # Addresses with long unicode display names.
+ (
+ "Tó Example very long" * 4 + " ",
+ "utf-8",
+ "=?utf-8?q?T=C3=B3_Example_very_longT=C3=B3_Example_very_longT"
+ "=C3=B3_Example_?=\n"
+ " =?utf-8?q?very_longT=C3=B3_Example_very_long?= "
+ "",
+ ),
+ (
+ ("Tó Example very long" * 4, "to@example.com"),
+ "utf-8",
+ "=?utf-8?q?T=C3=B3_Example_very_longT=C3=B3_Example_very_longT"
+ "=C3=B3_Example_?=\n"
+ " =?utf-8?q?very_longT=C3=B3_Example_very_long?= "
+ "",
+ ),
+ # Address with long display name and unicode domain.
+ (
+ ("To Example very long" * 4, "to@exampl€.com"),
+ "utf-8",
+ "To Example very longTo Example very longTo Example very longT"
+ "o Example very\n"
+ " long ",
+ ),
+ ):
+ with self.subTest(email_address=email_address, encoding=encoding):
+ self.assertEqual(
+ sanitize_address(email_address, encoding), expected_result
+ )
+
+ def test_sanitize_address_invalid(self):
+ for email_address in (
+ # Invalid address with two @ signs.
+ "to@other.com@example.com",
+ # Invalid address without the quotes.
+ "to@other.com ",
+ # Other invalid addresses.
+ "@",
+ "to@",
+ "@example.com",
+ ):
+ with self.subTest(email_address=email_address):
+ with self.assertRaises(ValueError):
+ sanitize_address(email_address, encoding="utf-8")
+
+ def test_sanitize_address_header_injection(self):
+ msg = "Invalid address; address parts cannot contain newlines."
+ tests = [
+ "Name\nInjection ",
+ ("Name\nInjection", "to@xample.com"),
+ "Name ",
+ ("Name", "to\ninjection@example.com"),
+ ]
+ for email_address in tests:
+ with self.subTest(email_address=email_address):
+ with self.assertRaisesMessage(ValueError, msg):
+ sanitize_address(email_address, encoding="utf-8")
+
+ def test_email_multi_alternatives_content_mimetype_none(self):
+ email_msg = EmailMultiAlternatives()
+ msg = "Both content and mimetype must be provided."
+ with self.assertRaisesMessage(ValueError, msg):
+ email_msg.attach_alternative(None, "text/html")
+ with self.assertRaisesMessage(ValueError, msg):
+ email_msg.attach_alternative("content
", None)
+
+
+@requires_tz_support
+class MailTimeZoneTests(SimpleTestCase):
+ @override_settings(
+ EMAIL_USE_LOCALTIME=False, USE_TZ=True, TIME_ZONE="Africa/Algiers"
+ )
+ def test_date_header_utc(self):
+ """
+ EMAIL_USE_LOCALTIME=False creates a datetime in UTC.
+ """
+ email = EmailMessage(
+ "Subject", "Body", "bounce@example.com", ["to@example.com"]
+ )
+ self.assertTrue(email.message()["Date"].endswith("-0000"))
+
+ @override_settings(
+ EMAIL_USE_LOCALTIME=True, USE_TZ=True, TIME_ZONE="Africa/Algiers"
+ )
+ def test_date_header_localtime(self):
+ """
+ EMAIL_USE_LOCALTIME=True creates a datetime in the local time zone.
+ """
+ email = EmailMessage(
+ "Subject", "Body", "bounce@example.com", ["to@example.com"]
+ )
+ self.assertTrue(
+ email.message()["Date"].endswith("+0100")
+ ) # Africa/Algiers is UTC+1
+
+
+class PythonGlobalState(SimpleTestCase):
+ """
+ Tests for #12422 -- Django smarts (#2472/#11212) with charset of utf-8 text
+ parts shouldn't pollute global email Python package charset registry when
+ django.mail.message is imported.
+ """
+
+ def test_utf8(self):
+ txt = MIMEText("UTF-8 encoded body", "plain", "utf-8")
+ self.assertIn("Content-Transfer-Encoding: base64", txt.as_string())
+
+ def test_7bit(self):
+ txt = MIMEText("Body with only ASCII characters.", "plain", "utf-8")
+ self.assertIn("Content-Transfer-Encoding: base64", txt.as_string())
+
+ def test_8bit_latin(self):
+ txt = MIMEText("Body with latin characters: àáä.", "plain", "utf-8")
+ self.assertIn("Content-Transfer-Encoding: base64", txt.as_string())
+
+ def test_8bit_non_latin(self):
+ txt = MIMEText(
+ "Body with non latin characters: А Б В Г Д Е Ж Ѕ З И І К Л М Н О П.",
+ "plain",
+ "utf-8",
+ )
+ self.assertIn("Content-Transfer-Encoding: base64", txt.as_string())
+
+
+class BaseEmailBackendTests(HeadersCheckMixin):
+ email_backend = None
+
+ def setUp(self):
+ self.settings_override = override_settings(EMAIL_BACKEND=self.email_backend)
+ self.settings_override.enable()
+
+ def tearDown(self):
+ self.settings_override.disable()
+
+ def assertStartsWith(self, first, second):
+ if not first.startswith(second):
+ self.longMessage = True
+ self.assertEqual(
+ first[: len(second)],
+ second,
+ "First string doesn't start with the second.",
+ )
+
+ def get_mailbox_content(self):
+ raise NotImplementedError(
+ "subclasses of BaseEmailBackendTests must provide a get_mailbox_content() "
+ "method"
+ )
+
+ def flush_mailbox(self):
+ raise NotImplementedError(
+ "subclasses of BaseEmailBackendTests may require a flush_mailbox() method"
+ )
+
+ def get_the_message(self):
+ mailbox = self.get_mailbox_content()
+ self.assertEqual(
+ len(mailbox),
+ 1,
+ "Expected exactly one message, got %d.\n%r"
+ % (len(mailbox), [m.as_string() for m in mailbox]),
+ )
+ return mailbox[0]
+
+ def test_send(self):
+ email = EmailMessage(
+ "Subject", "Content", "from@example.com", ["to@example.com"]
+ )
+ num_sent = mail.get_connection().send_messages([email])
+ self.assertEqual(num_sent, 1)
+ message = self.get_the_message()
+ self.assertEqual(message["subject"], "Subject")
+ self.assertEqual(message.get_payload(), "Content")
+ self.assertEqual(message["from"], "from@example.com")
+ self.assertEqual(message.get_all("to"), ["to@example.com"])
+
+ def test_send_unicode(self):
+ email = EmailMessage(
+ "Chère maman", "Je t'aime très fort", "from@example.com", ["to@example.com"]
+ )
+ num_sent = mail.get_connection().send_messages([email])
+ self.assertEqual(num_sent, 1)
+ message = self.get_the_message()
+ self.assertEqual(message["subject"], "=?utf-8?q?Ch=C3=A8re_maman?=")
+ self.assertEqual(
+ message.get_payload(decode=True).decode(), "Je t'aime très fort"
+ )
+
+ def test_send_long_lines(self):
+ """
+ Email line length is limited to 998 chars by the RFC 5322 Section
+ 2.1.1.
+ Message body containing longer lines are converted to Quoted-Printable
+ to avoid having to insert newlines, which could be hairy to do properly.
+ """
+ # Unencoded body length is < 998 (840) but > 998 when utf-8 encoded.
+ email = EmailMessage(
+ "Subject", "В южных морях " * 60, "from@example.com", ["to@example.com"]
+ )
+ email.send()
+ message = self.get_the_message()
+ self.assertMessageHasHeaders(
+ message,
+ {
+ ("MIME-Version", "1.0"),
+ ("Content-Type", 'text/plain; charset="utf-8"'),
+ ("Content-Transfer-Encoding", "quoted-printable"),
+ },
+ )
+
+ def test_send_many(self):
+ email1 = EmailMessage(
+ "Subject", "Content1", "from@example.com", ["to@example.com"]
+ )
+ email2 = EmailMessage(
+ "Subject", "Content2", "from@example.com", ["to@example.com"]
+ )
+ # send_messages() may take a list or an iterator.
+ emails_lists = ([email1, email2], iter((email1, email2)))
+ for emails_list in emails_lists:
+ num_sent = mail.get_connection().send_messages(emails_list)
+ self.assertEqual(num_sent, 2)
+ messages = self.get_mailbox_content()
+ self.assertEqual(len(messages), 2)
+ self.assertEqual(messages[0].get_payload(), "Content1")
+ self.assertEqual(messages[1].get_payload(), "Content2")
+ self.flush_mailbox()
+
+ def test_send_verbose_name(self):
+ email = EmailMessage(
+ "Subject",
+ "Content",
+ '"Firstname Sürname" ',
+ ["to@example.com"],
+ )
+ email.send()
+ message = self.get_the_message()
+ self.assertEqual(message["subject"], "Subject")
+ self.assertEqual(message.get_payload(), "Content")
+ self.assertEqual(
+ message["from"], "=?utf-8?q?Firstname_S=C3=BCrname?= "
+ )
+
+ def test_plaintext_send_mail(self):
+ """
+ Test send_mail without the html_message
+ regression test for adding html_message parameter to send_mail()
+ """
+ send_mail("Subject", "Content", "sender@example.com", ["nobody@example.com"])
+ message = self.get_the_message()
+
+ self.assertEqual(message.get("subject"), "Subject")
+ self.assertEqual(message.get_all("to"), ["nobody@example.com"])
+ self.assertFalse(message.is_multipart())
+ self.assertEqual(message.get_payload(), "Content")
+ self.assertEqual(message.get_content_type(), "text/plain")
+
+ def test_html_send_mail(self):
+ """Test html_message argument to send_mail"""
+ send_mail(
+ "Subject",
+ "Content",
+ "sender@example.com",
+ ["nobody@example.com"],
+ html_message="HTML Content",
+ )
+ message = self.get_the_message()
+
+ self.assertEqual(message.get("subject"), "Subject")
+ self.assertEqual(message.get_all("to"), ["nobody@example.com"])
+ self.assertTrue(message.is_multipart())
+ self.assertEqual(len(message.get_payload()), 2)
+ self.assertEqual(message.get_payload(0).get_payload(), "Content")
+ self.assertEqual(message.get_payload(0).get_content_type(), "text/plain")
+ self.assertEqual(message.get_payload(1).get_payload(), "HTML Content")
+ self.assertEqual(message.get_payload(1).get_content_type(), "text/html")
+
+ @override_settings(MANAGERS=[("nobody", "nobody@example.com")])
+ def test_html_mail_managers(self):
+ """Test html_message argument to mail_managers"""
+ mail_managers("Subject", "Content", html_message="HTML Content")
+ message = self.get_the_message()
+
+ self.assertEqual(message.get("subject"), "[Django] Subject")
+ self.assertEqual(message.get_all("to"), ["nobody@example.com"])
+ self.assertTrue(message.is_multipart())
+ self.assertEqual(len(message.get_payload()), 2)
+ self.assertEqual(message.get_payload(0).get_payload(), "Content")
+ self.assertEqual(message.get_payload(0).get_content_type(), "text/plain")
+ self.assertEqual(message.get_payload(1).get_payload(), "HTML Content")
+ self.assertEqual(message.get_payload(1).get_content_type(), "text/html")
+
+ @override_settings(ADMINS=[("nobody", "nobody@example.com")])
+ def test_html_mail_admins(self):
+ """Test html_message argument to mail_admins"""
+ mail_admins("Subject", "Content", html_message="HTML Content")
+ message = self.get_the_message()
+
+ self.assertEqual(message.get("subject"), "[Django] Subject")
+ self.assertEqual(message.get_all("to"), ["nobody@example.com"])
+ self.assertTrue(message.is_multipart())
+ self.assertEqual(len(message.get_payload()), 2)
+ self.assertEqual(message.get_payload(0).get_payload(), "Content")
+ self.assertEqual(message.get_payload(0).get_content_type(), "text/plain")
+ self.assertEqual(message.get_payload(1).get_payload(), "HTML Content")
+ self.assertEqual(message.get_payload(1).get_content_type(), "text/html")
+
+ @override_settings(
+ ADMINS=[("nobody", "nobody+admin@example.com")],
+ MANAGERS=[("nobody", "nobody+manager@example.com")],
+ )
+ def test_manager_and_admin_mail_prefix(self):
+ """
+ String prefix + lazy translated subject = bad output
+ Regression for #13494
+ """
+ mail_managers(gettext_lazy("Subject"), "Content")
+ message = self.get_the_message()
+ self.assertEqual(message.get("subject"), "[Django] Subject")
+
+ self.flush_mailbox()
+ mail_admins(gettext_lazy("Subject"), "Content")
+ message = self.get_the_message()
+ self.assertEqual(message.get("subject"), "[Django] Subject")
+
+ @override_settings(ADMINS=[], MANAGERS=[])
+ def test_empty_admins(self):
+ """
+ mail_admins/mail_managers doesn't connect to the mail server
+ if there are no recipients (#9383)
+ """
+ mail_admins("hi", "there")
+ self.assertEqual(self.get_mailbox_content(), [])
+ mail_managers("hi", "there")
+ self.assertEqual(self.get_mailbox_content(), [])
+
+ def test_wrong_admins_managers(self):
+ tests = (
+ "test@example.com",
+ ("test@example.com",),
+ ["test@example.com", "other@example.com"],
+ ("test@example.com", "other@example.com"),
+ )
+ for setting, mail_func in (
+ ("ADMINS", mail_admins),
+ ("MANAGERS", mail_managers),
+ ):
+ msg = "The %s setting must be a list of 2-tuples." % setting
+ for value in tests:
+ with self.subTest(setting=setting, value=value), self.settings(
+ **{setting: value}
+ ):
+ with self.assertRaisesMessage(ValueError, msg):
+ mail_func("subject", "content")
+
+ def test_message_cc_header(self):
+ """
+ Regression test for #7722
+ """
+ email = EmailMessage(
+ "Subject",
+ "Content",
+ "from@example.com",
+ ["to@example.com"],
+ cc=["cc@example.com"],
+ )
+ mail.get_connection().send_messages([email])
+ message = self.get_the_message()
+ self.assertMessageHasHeaders(
+ message,
+ {
+ ("MIME-Version", "1.0"),
+ ("Content-Type", 'text/plain; charset="utf-8"'),
+ ("Content-Transfer-Encoding", "7bit"),
+ ("Subject", "Subject"),
+ ("From", "from@example.com"),
+ ("To", "to@example.com"),
+ ("Cc", "cc@example.com"),
+ },
+ )
+ self.assertIn("\nDate: ", message.as_string())
+
+ def test_idn_send(self):
+ """
+ Regression test for #14301
+ """
+ self.assertTrue(send_mail("Subject", "Content", "from@öäü.com", ["to@öäü.com"]))
+ message = self.get_the_message()
+ self.assertEqual(message.get("subject"), "Subject")
+ self.assertEqual(message.get("from"), "from@xn--4ca9at.com")
+ self.assertEqual(message.get("to"), "to@xn--4ca9at.com")
+
+ self.flush_mailbox()
+ m = EmailMessage(
+ "Subject", "Content", "from@öäü.com", ["to@öäü.com"], cc=["cc@öäü.com"]
+ )
+ m.send()
+ message = self.get_the_message()
+ self.assertEqual(message.get("subject"), "Subject")
+ self.assertEqual(message.get("from"), "from@xn--4ca9at.com")
+ self.assertEqual(message.get("to"), "to@xn--4ca9at.com")
+ self.assertEqual(message.get("cc"), "cc@xn--4ca9at.com")
+
+ def test_recipient_without_domain(self):
+ """
+ Regression test for #15042
+ """
+ self.assertTrue(send_mail("Subject", "Content", "tester", ["django"]))
+ message = self.get_the_message()
+ self.assertEqual(message.get("subject"), "Subject")
+ self.assertEqual(message.get("from"), "tester")
+ self.assertEqual(message.get("to"), "django")
+
+ def test_lazy_addresses(self):
+ """
+ Email sending should support lazy email addresses (#24416).
+ """
+ _ = gettext_lazy
+ self.assertTrue(send_mail("Subject", "Content", _("tester"), [_("django")]))
+ message = self.get_the_message()
+ self.assertEqual(message.get("from"), "tester")
+ self.assertEqual(message.get("to"), "django")
+
+ self.flush_mailbox()
+ m = EmailMessage(
+ "Subject",
+ "Content",
+ _("tester"),
+ [_("to1"), _("to2")],
+ cc=[_("cc1"), _("cc2")],
+ bcc=[_("bcc")],
+ reply_to=[_("reply")],
+ )
+ self.assertEqual(m.recipients(), ["to1", "to2", "cc1", "cc2", "bcc"])
+ m.send()
+ message = self.get_the_message()
+ self.assertEqual(message.get("from"), "tester")
+ self.assertEqual(message.get("to"), "to1, to2")
+ self.assertEqual(message.get("cc"), "cc1, cc2")
+ self.assertEqual(message.get("Reply-To"), "reply")
+
+ def test_close_connection(self):
+ """
+ Connection can be closed (even when not explicitly opened)
+ """
+ conn = mail.get_connection(username="", password="")
+ conn.close()
+
+ def test_use_as_contextmanager(self):
+ """
+ The connection can be used as a contextmanager.
+ """
+ opened = [False]
+ closed = [False]
+ conn = mail.get_connection(username="", password="")
+
+ def open():
+ opened[0] = True
+
+ conn.open = open
+
+ def close():
+ closed[0] = True
+
+ conn.close = close
+ with conn as same_conn:
+ self.assertTrue(opened[0])
+ self.assertIs(same_conn, conn)
+ self.assertFalse(closed[0])
+ self.assertTrue(closed[0])
+
+
+class LocmemBackendTests(BaseEmailBackendTests, SimpleTestCase):
+ email_backend = "django.core.mail.backends.locmem.EmailBackend"
+
+ def get_mailbox_content(self):
+ return [m.message() for m in mail.outbox]
+
+ def flush_mailbox(self):
+ mail.outbox = []
+
+ def tearDown(self):
+ super().tearDown()
+ mail.outbox = []
+
+ def test_locmem_shared_messages(self):
+ """
+ Make sure that the locmen backend populates the outbox.
+ """
+ connection = locmem.EmailBackend()
+ connection2 = locmem.EmailBackend()
+ email = EmailMessage(
+ "Subject",
+ "Content",
+ "bounce@example.com",
+ ["to@example.com"],
+ headers={"From": "from@example.com"},
+ )
+ connection.send_messages([email])
+ connection2.send_messages([email])
+ self.assertEqual(len(mail.outbox), 2)
+
+ def test_validate_multiline_headers(self):
+ # Ticket #18861 - Validate emails when using the locmem backend
+ with self.assertRaises(BadHeaderError):
+ send_mail(
+ "Subject\nMultiline", "Content", "from@example.com", ["to@example.com"]
+ )
+
+
+class FileBackendTests(BaseEmailBackendTests, SimpleTestCase):
+ email_backend = "django.core.mail.backends.filebased.EmailBackend"
+
+ def setUp(self):
+ super().setUp()
+ self.tmp_dir = self.mkdtemp()
+ self.addCleanup(shutil.rmtree, self.tmp_dir)
+ self._settings_override = override_settings(EMAIL_FILE_PATH=self.tmp_dir)
+ self._settings_override.enable()
+
+ def tearDown(self):
+ self._settings_override.disable()
+ super().tearDown()
+
+ def mkdtemp(self):
+ return tempfile.mkdtemp()
+
+ def flush_mailbox(self):
+ for filename in os.listdir(self.tmp_dir):
+ os.unlink(os.path.join(self.tmp_dir, filename))
+
+ def get_mailbox_content(self):
+ messages = []
+ for filename in os.listdir(self.tmp_dir):
+ with open(os.path.join(self.tmp_dir, filename), "rb") as fp:
+ session = fp.read().split(b"\n" + (b"-" * 79) + b"\n")
+ messages.extend(message_from_bytes(m) for m in session if m)
+ return messages
+
+ def test_file_sessions(self):
+ """Make sure opening a connection creates a new file"""
+ msg = EmailMessage(
+ "Subject",
+ "Content",
+ "bounce@example.com",
+ ["to@example.com"],
+ headers={"From": "from@example.com"},
+ )
+ connection = mail.get_connection()
+ connection.send_messages([msg])
+
+ self.assertEqual(len(os.listdir(self.tmp_dir)), 1)
+ with open(os.path.join(self.tmp_dir, os.listdir(self.tmp_dir)[0]), "rb") as fp:
+ message = message_from_binary_file(fp)
+ self.assertEqual(message.get_content_type(), "text/plain")
+ self.assertEqual(message.get("subject"), "Subject")
+ self.assertEqual(message.get("from"), "from@example.com")
+ self.assertEqual(message.get("to"), "to@example.com")
+
+ connection2 = mail.get_connection()
+ connection2.send_messages([msg])
+ self.assertEqual(len(os.listdir(self.tmp_dir)), 2)
+
+ connection.send_messages([msg])
+ self.assertEqual(len(os.listdir(self.tmp_dir)), 2)
+
+ msg.connection = mail.get_connection()
+ self.assertTrue(connection.open())
+ msg.send()
+ self.assertEqual(len(os.listdir(self.tmp_dir)), 3)
+ msg.send()
+ self.assertEqual(len(os.listdir(self.tmp_dir)), 3)
+
+ connection.close()
+
+
+class FileBackendPathLibTests(FileBackendTests):
+ def mkdtemp(self):
+ tmp_dir = super().mkdtemp()
+ return Path(tmp_dir)
+
+
+class ConsoleBackendTests(BaseEmailBackendTests, SimpleTestCase):
+ email_backend = "django.core.mail.backends.console.EmailBackend"
+
+ def setUp(self):
+ super().setUp()
+ self.__stdout = sys.stdout
+ self.stream = sys.stdout = StringIO()
+
+ def tearDown(self):
+ del self.stream
+ sys.stdout = self.__stdout
+ del self.__stdout
+ super().tearDown()
+
+ def flush_mailbox(self):
+ self.stream = sys.stdout = StringIO()
+
+ def get_mailbox_content(self):
+ messages = self.stream.getvalue().split("\n" + ("-" * 79) + "\n")
+ return [message_from_bytes(m.encode()) for m in messages if m]
+
+ def test_console_stream_kwarg(self):
+ """
+ The console backend can be pointed at an arbitrary stream.
+ """
+ s = StringIO()
+ connection = mail.get_connection(
+ "django.core.mail.backends.console.EmailBackend", stream=s
+ )
+ send_mail(
+ "Subject",
+ "Content",
+ "from@example.com",
+ ["to@example.com"],
+ connection=connection,
+ )
+ message = s.getvalue().split("\n" + ("-" * 79) + "\n")[0].encode()
+ self.assertMessageHasHeaders(
+ message,
+ {
+ ("MIME-Version", "1.0"),
+ ("Content-Type", 'text/plain; charset="utf-8"'),
+ ("Content-Transfer-Encoding", "7bit"),
+ ("Subject", "Subject"),
+ ("From", "from@example.com"),
+ ("To", "to@example.com"),
+ },
+ )
+ self.assertIn(b"\nDate: ", message)
+
+
+class SMTPHandler:
+ def __init__(self, *args, **kwargs):
+ self.mailbox = []
+
+ async def handle_DATA(self, server, session, envelope):
+ data = envelope.content
+ mail_from = envelope.mail_from
+
+ message = message_from_bytes(data.rstrip())
+ message_addr = parseaddr(message.get("from"))[1]
+ if mail_from != message_addr:
+ # According to the spec, mail_from does not necessarily match the
+ # From header - this is the case where the local part isn't
+ # encoded, so try to correct that.
+ lp, domain = mail_from.split("@", 1)
+ lp = Header(lp, "utf-8").encode()
+ mail_from = "@".join([lp, domain])
+
+ if mail_from != message_addr:
+ return f"553 '{mail_from}' != '{message_addr}'"
+ self.mailbox.append(message)
+ return "250 OK"
+
+ def flush_mailbox(self):
+ self.mailbox[:] = []
+
+
+@skipUnless(HAS_AIOSMTPD, "No aiosmtpd library detected.")
+class SMTPBackendTestsBase(SimpleTestCase):
+ @classmethod
+ def setUpClass(cls):
+ super().setUpClass()
+ # Find a free port.
+ with socket.socket() as s:
+ s.bind(("127.0.0.1", 0))
+ port = s.getsockname()[1]
+ cls.smtp_handler = SMTPHandler()
+ cls.smtp_controller = Controller(
+ cls.smtp_handler,
+ hostname="127.0.0.1",
+ port=port,
+ )
+ cls._settings_override = override_settings(
+ EMAIL_HOST=cls.smtp_controller.hostname,
+ EMAIL_PORT=cls.smtp_controller.port,
+ )
+ cls._settings_override.enable()
+ cls.addClassCleanup(cls._settings_override.disable)
+ cls.smtp_controller.start()
+ cls.addClassCleanup(cls.stop_smtp)
+
+ @classmethod
+ def stop_smtp(cls):
+ cls.smtp_controller.stop()
+
+
+@skipUnless(HAS_AIOSMTPD, "No aiosmtpd library detected.")
+class SMTPBackendTests(BaseEmailBackendTests, SMTPBackendTestsBase):
+ email_backend = "django.core.mail.backends.smtp.EmailBackend"
+
+ def setUp(self):
+ super().setUp()
+ self.smtp_handler.flush_mailbox()
+
+ def tearDown(self):
+ self.smtp_handler.flush_mailbox()
+ super().tearDown()
+
+ def flush_mailbox(self):
+ self.smtp_handler.flush_mailbox()
+
+ def get_mailbox_content(self):
+ return self.smtp_handler.mailbox
+
+ @override_settings(
+ EMAIL_HOST_USER="not empty username",
+ EMAIL_HOST_PASSWORD="not empty password",
+ )
+ def test_email_authentication_use_settings(self):
+ backend = smtp.EmailBackend()
+ self.assertEqual(backend.username, "not empty username")
+ self.assertEqual(backend.password, "not empty password")
+
+ @override_settings(
+ EMAIL_HOST_USER="not empty username",
+ EMAIL_HOST_PASSWORD="not empty password",
+ )
+ def test_email_authentication_override_settings(self):
+ backend = smtp.EmailBackend(username="username", password="password")
+ self.assertEqual(backend.username, "username")
+ self.assertEqual(backend.password, "password")
+
+ @override_settings(
+ EMAIL_HOST_USER="not empty username",
+ EMAIL_HOST_PASSWORD="not empty password",
+ )
+ def test_email_disabled_authentication(self):
+ backend = smtp.EmailBackend(username="", password="")
+ self.assertEqual(backend.username, "")
+ self.assertEqual(backend.password, "")
+
+ def test_auth_attempted(self):
+ """
+ Opening the backend with non empty username/password tries
+ to authenticate against the SMTP server.
+ """
+ backend = smtp.EmailBackend(
+ username="not empty username", password="not empty password"
+ )
+ with self.assertRaisesMessage(
+ SMTPException, "SMTP AUTH extension not supported by server."
+ ):
+ with backend:
+ pass
+
+ def test_server_open(self):
+ """
+ open() returns whether it opened a connection.
+ """
+ backend = smtp.EmailBackend(username="", password="")
+ self.assertIsNone(backend.connection)
+ opened = backend.open()
+ backend.close()
+ self.assertIs(opened, True)
+
+ def test_reopen_connection(self):
+ backend = smtp.EmailBackend()
+ # Simulate an already open connection.
+ backend.connection = mock.Mock(spec=object())
+ self.assertIs(backend.open(), False)
+
+ @override_settings(EMAIL_USE_TLS=True)
+ def test_email_tls_use_settings(self):
+ backend = smtp.EmailBackend()
+ self.assertTrue(backend.use_tls)
+
+ @override_settings(EMAIL_USE_TLS=True)
+ def test_email_tls_override_settings(self):
+ backend = smtp.EmailBackend(use_tls=False)
+ self.assertFalse(backend.use_tls)
+
+ def test_email_tls_default_disabled(self):
+ backend = smtp.EmailBackend()
+ self.assertFalse(backend.use_tls)
+
+ def test_ssl_tls_mutually_exclusive(self):
+ msg = (
+ "EMAIL_USE_TLS/EMAIL_USE_SSL are mutually exclusive, so only set "
+ "one of those settings to True."
+ )
+ with self.assertRaisesMessage(ValueError, msg):
+ smtp.EmailBackend(use_ssl=True, use_tls=True)
+
+ @override_settings(EMAIL_USE_SSL=True)
+ def test_email_ssl_use_settings(self):
+ backend = smtp.EmailBackend()
+ self.assertTrue(backend.use_ssl)
+
+ @override_settings(EMAIL_USE_SSL=True)
+ def test_email_ssl_override_settings(self):
+ backend = smtp.EmailBackend(use_ssl=False)
+ self.assertFalse(backend.use_ssl)
+
+ def test_email_ssl_default_disabled(self):
+ backend = smtp.EmailBackend()
+ self.assertFalse(backend.use_ssl)
+
+ @override_settings(EMAIL_SSL_CERTFILE="foo")
+ def test_email_ssl_certfile_use_settings(self):
+ backend = smtp.EmailBackend()
+ self.assertEqual(backend.ssl_certfile, "foo")
+
+ @override_settings(EMAIL_SSL_CERTFILE="foo")
+ def test_email_ssl_certfile_override_settings(self):
+ backend = smtp.EmailBackend(ssl_certfile="bar")
+ self.assertEqual(backend.ssl_certfile, "bar")
+
+ def test_email_ssl_certfile_default_disabled(self):
+ backend = smtp.EmailBackend()
+ self.assertIsNone(backend.ssl_certfile)
+
+ @override_settings(EMAIL_SSL_KEYFILE="foo")
+ def test_email_ssl_keyfile_use_settings(self):
+ backend = smtp.EmailBackend()
+ self.assertEqual(backend.ssl_keyfile, "foo")
+
+ @override_settings(EMAIL_SSL_KEYFILE="foo")
+ def test_email_ssl_keyfile_override_settings(self):
+ backend = smtp.EmailBackend(ssl_keyfile="bar")
+ self.assertEqual(backend.ssl_keyfile, "bar")
+
+ def test_email_ssl_keyfile_default_disabled(self):
+ backend = smtp.EmailBackend()
+ self.assertIsNone(backend.ssl_keyfile)
+
+ @override_settings(EMAIL_USE_TLS=True)
+ def test_email_tls_attempts_starttls(self):
+ backend = smtp.EmailBackend()
+ self.assertTrue(backend.use_tls)
+ with self.assertRaisesMessage(
+ SMTPException, "STARTTLS extension not supported by server."
+ ):
+ with backend:
+ pass
+
+ @override_settings(EMAIL_USE_SSL=True)
+ def test_email_ssl_attempts_ssl_connection(self):
+ backend = smtp.EmailBackend()
+ self.assertTrue(backend.use_ssl)
+ with self.assertRaises(SSLError):
+ with backend:
+ pass
+
+ def test_connection_timeout_default(self):
+ """The connection's timeout value is None by default."""
+ connection = mail.get_connection("django.core.mail.backends.smtp.EmailBackend")
+ self.assertIsNone(connection.timeout)
+
+ def test_connection_timeout_custom(self):
+ """The timeout parameter can be customized."""
+
+ class MyEmailBackend(smtp.EmailBackend):
+ def __init__(self, *args, **kwargs):
+ kwargs.setdefault("timeout", 42)
+ super().__init__(*args, **kwargs)
+
+ myemailbackend = MyEmailBackend()
+ myemailbackend.open()
+ self.assertEqual(myemailbackend.timeout, 42)
+ self.assertEqual(myemailbackend.connection.timeout, 42)
+ myemailbackend.close()
+
+ @override_settings(EMAIL_TIMEOUT=10)
+ def test_email_timeout_override_settings(self):
+ backend = smtp.EmailBackend()
+ self.assertEqual(backend.timeout, 10)
+
+ def test_email_msg_uses_crlf(self):
+ """#23063 -- RFC-compliant messages are sent over SMTP."""
+ send = SMTP.send
+ try:
+ smtp_messages = []
+
+ def mock_send(self, s):
+ smtp_messages.append(s)
+ return send(self, s)
+
+ SMTP.send = mock_send
+
+ email = EmailMessage(
+ "Subject", "Content", "from@example.com", ["to@example.com"]
+ )
+ mail.get_connection().send_messages([email])
+
+ # Find the actual message
+ msg = None
+ for i, m in enumerate(smtp_messages):
+ if m[:4] == "data":
+ msg = smtp_messages[i + 1]
+ break
+
+ self.assertTrue(msg)
+
+ msg = msg.decode()
+ # The message only contains CRLF and not combinations of CRLF, LF, and CR.
+ msg = msg.replace("\r\n", "")
+ self.assertNotIn("\r", msg)
+ self.assertNotIn("\n", msg)
+
+ finally:
+ SMTP.send = send
+
+ def test_send_messages_after_open_failed(self):
+ """
+ send_messages() shouldn't try to send messages if open() raises an
+ exception after initializing the connection.
+ """
+ backend = smtp.EmailBackend()
+ # Simulate connection initialization success and a subsequent
+ # connection exception.
+ backend.connection = mock.Mock(spec=object())
+ backend.open = lambda: None
+ email = EmailMessage(
+ "Subject", "Content", "from@example.com", ["to@example.com"]
+ )
+ self.assertEqual(backend.send_messages([email]), 0)
+
+ def test_send_messages_empty_list(self):
+ backend = smtp.EmailBackend()
+ backend.connection = mock.Mock(spec=object())
+ self.assertEqual(backend.send_messages([]), 0)
+
+ def test_send_messages_zero_sent(self):
+ """A message isn't sent if it doesn't have any recipients."""
+ backend = smtp.EmailBackend()
+ backend.connection = mock.Mock(spec=object())
+ email = EmailMessage("Subject", "Content", "from@example.com", to=[])
+ sent = backend.send_messages([email])
+ self.assertEqual(sent, 0)
+
+
+@skipUnless(HAS_AIOSMTPD, "No aiosmtpd library detected.")
+class SMTPBackendStoppedServerTests(SMTPBackendTestsBase):
+ @classmethod
+ def setUpClass(cls):
+ super().setUpClass()
+ cls.backend = smtp.EmailBackend(username="", password="")
+ cls.smtp_controller.stop()
+
+ @classmethod
+ def stop_smtp(cls):
+ # SMTP controller is stopped in setUpClass().
+ pass
+
+ def test_server_stopped(self):
+ """
+ Closing the backend while the SMTP server is stopped doesn't raise an
+ exception.
+ """
+ self.backend.close()
+
+ def test_fail_silently_on_connection_error(self):
+ """
+ A socket connection error is silenced with fail_silently=True.
+ """
+ with self.assertRaises(ConnectionError):
+ self.backend.open()
+ self.backend.fail_silently = True
+ self.backend.open()
diff --git a/testbed/django__django/tests/managers_regress/__init__.py b/testbed/django__django/tests/managers_regress/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testbed/django__django/tests/managers_regress/models.py b/testbed/django__django/tests/managers_regress/models.py
new file mode 100644
index 0000000000000000000000000000000000000000..dd365d961d2f51fac71ee1240b446993067f17f2
--- /dev/null
+++ b/testbed/django__django/tests/managers_regress/models.py
@@ -0,0 +1,138 @@
+"""
+Various edge-cases for model managers.
+"""
+
+from django.contrib.contenttypes.fields import GenericForeignKey, GenericRelation
+from django.contrib.contenttypes.models import ContentType
+from django.db import models
+
+
+class OnlyFred(models.Manager):
+ def get_queryset(self):
+ return super().get_queryset().filter(name="fred")
+
+
+class OnlyBarney(models.Manager):
+ def get_queryset(self):
+ return super().get_queryset().filter(name="barney")
+
+
+class Value42(models.Manager):
+ def get_queryset(self):
+ return super().get_queryset().filter(value=42)
+
+
+class AbstractBase1(models.Model):
+ name = models.CharField(max_length=50)
+
+ class Meta:
+ abstract = True
+
+ # Custom managers
+ manager1 = OnlyFred()
+ manager2 = OnlyBarney()
+ objects = models.Manager()
+
+
+class AbstractBase2(models.Model):
+ value = models.IntegerField()
+
+ class Meta:
+ abstract = True
+
+ # Custom manager
+ restricted = Value42()
+
+
+# No custom manager on this class to make sure the default case doesn't break.
+class AbstractBase3(models.Model):
+ comment = models.CharField(max_length=50)
+
+ class Meta:
+ abstract = True
+
+
+class Parent(models.Model):
+ name = models.CharField(max_length=50)
+
+ manager = OnlyFred()
+
+ def __str__(self):
+ return self.name
+
+
+# Managers from base classes are inherited and, if no manager is specified
+# *and* the parent has a manager specified, the first one (in the MRO) will
+# become the default.
+class Child1(AbstractBase1):
+ data = models.CharField(max_length=25)
+
+ def __str__(self):
+ return self.data
+
+
+class Child2(AbstractBase1, AbstractBase2):
+ data = models.CharField(max_length=25)
+
+ def __str__(self):
+ return self.data
+
+
+class Child3(AbstractBase1, AbstractBase3):
+ data = models.CharField(max_length=25)
+
+ def __str__(self):
+ return self.data
+
+
+class Child4(AbstractBase1):
+ data = models.CharField(max_length=25)
+
+ # Should be the default manager, although the parent managers are
+ # inherited.
+ default = models.Manager()
+
+ def __str__(self):
+ return self.data
+
+
+class Child5(AbstractBase3):
+ name = models.CharField(max_length=25)
+
+ default = OnlyFred()
+ objects = models.Manager()
+
+ def __str__(self):
+ return self.name
+
+
+class Child6(Child4):
+ value = models.IntegerField()
+
+
+class Child7(Parent):
+ objects = models.Manager()
+
+
+# RelatedManagers
+class RelatedModel(models.Model):
+ test_gfk = GenericRelation(
+ "RelationModel", content_type_field="gfk_ctype", object_id_field="gfk_id"
+ )
+ exact = models.BooleanField(null=True)
+
+ def __str__(self):
+ return str(self.pk)
+
+
+class RelationModel(models.Model):
+ fk = models.ForeignKey(RelatedModel, models.CASCADE, related_name="test_fk")
+
+ m2m = models.ManyToManyField(RelatedModel, related_name="test_m2m")
+
+ gfk_ctype = models.ForeignKey(ContentType, models.SET_NULL, null=True)
+ gfk_id = models.IntegerField(null=True)
+ gfk = GenericForeignKey(ct_field="gfk_ctype", fk_field="gfk_id")
+
+ def __str__(self):
+ return str(self.pk)
diff --git a/testbed/django__django/tests/managers_regress/tests.py b/testbed/django__django/tests/managers_regress/tests.py
new file mode 100644
index 0000000000000000000000000000000000000000..33192a1699e20e37dd80513e76cb190af664603a
--- /dev/null
+++ b/testbed/django__django/tests/managers_regress/tests.py
@@ -0,0 +1,303 @@
+from django.db import models
+from django.template import Context, Template
+from django.test import SimpleTestCase, TestCase, override_settings
+from django.test.utils import isolate_apps
+
+from .models import (
+ AbstractBase1,
+ AbstractBase2,
+ AbstractBase3,
+ Child1,
+ Child2,
+ Child3,
+ Child4,
+ Child5,
+ Child6,
+ Child7,
+ RelatedModel,
+ RelationModel,
+)
+
+
+class ManagersRegressionTests(TestCase):
+ def test_managers(self):
+ a1 = Child1.objects.create(name="fred", data="a1")
+ a2 = Child1.objects.create(name="barney", data="a2")
+ b1 = Child2.objects.create(name="fred", data="b1", value=1)
+ b2 = Child2.objects.create(name="barney", data="b2", value=42)
+ c1 = Child3.objects.create(name="fred", data="c1", comment="yes")
+ c2 = Child3.objects.create(name="barney", data="c2", comment="no")
+ d1 = Child4.objects.create(name="fred", data="d1")
+ d2 = Child4.objects.create(name="barney", data="d2")
+ fred1 = Child5.objects.create(name="fred", comment="yes")
+ Child5.objects.create(name="barney", comment="no")
+ f1 = Child6.objects.create(name="fred", data="f1", value=42)
+ f2 = Child6.objects.create(name="barney", data="f2", value=42)
+ fred2 = Child7.objects.create(name="fred")
+ barney = Child7.objects.create(name="barney")
+
+ self.assertSequenceEqual(Child1.manager1.all(), [a1])
+ self.assertSequenceEqual(Child1.manager2.all(), [a2])
+ self.assertSequenceEqual(Child1._default_manager.all(), [a1])
+
+ self.assertSequenceEqual(Child2._default_manager.all(), [b1])
+ self.assertSequenceEqual(Child2.restricted.all(), [b2])
+
+ self.assertSequenceEqual(Child3._default_manager.all(), [c1])
+ self.assertSequenceEqual(Child3.manager1.all(), [c1])
+ self.assertSequenceEqual(Child3.manager2.all(), [c2])
+
+ # Since Child6 inherits from Child4, the corresponding rows from f1 and
+ # f2 also appear here. This is the expected result.
+ self.assertSequenceEqual(
+ Child4._default_manager.order_by("data"),
+ [d1, d2, f1.child4_ptr, f2.child4_ptr],
+ )
+ self.assertCountEqual(Child4.manager1.all(), [d1, f1.child4_ptr])
+ self.assertCountEqual(Child5._default_manager.all(), [fred1])
+ self.assertCountEqual(Child6._default_manager.all(), [f1, f2])
+ self.assertSequenceEqual(
+ Child7._default_manager.order_by("name"),
+ [barney, fred2],
+ )
+
+ def test_abstract_manager(self):
+ # Accessing the manager on an abstract model should
+ # raise an attribute error with an appropriate message.
+ # This error message isn't ideal, but if the model is abstract and
+ # a lot of the class instantiation logic isn't invoked; if the
+ # manager is implied, then we don't get a hook to install the
+ # error-raising manager.
+ msg = "type object 'AbstractBase3' has no attribute 'objects'"
+ with self.assertRaisesMessage(AttributeError, msg):
+ AbstractBase3.objects.all()
+
+ def test_custom_abstract_manager(self):
+ # Accessing the manager on an abstract model with a custom
+ # manager should raise an attribute error with an appropriate
+ # message.
+ msg = "Manager isn't available; AbstractBase2 is abstract"
+ with self.assertRaisesMessage(AttributeError, msg):
+ AbstractBase2.restricted.all()
+
+ def test_explicit_abstract_manager(self):
+ # Accessing the manager on an abstract model with an explicit
+ # manager should raise an attribute error with an appropriate
+ # message.
+ msg = "Manager isn't available; AbstractBase1 is abstract"
+ with self.assertRaisesMessage(AttributeError, msg):
+ AbstractBase1.objects.all()
+
+ @override_settings(TEST_SWAPPABLE_MODEL="managers_regress.Parent")
+ @isolate_apps("managers_regress")
+ def test_swappable_manager(self):
+ class SwappableModel(models.Model):
+ class Meta:
+ swappable = "TEST_SWAPPABLE_MODEL"
+
+ # Accessing the manager on a swappable model should
+ # raise an attribute error with a helpful message
+ msg = (
+ "Manager isn't available; 'managers_regress.SwappableModel' "
+ "has been swapped for 'managers_regress.Parent'"
+ )
+ with self.assertRaisesMessage(AttributeError, msg):
+ SwappableModel.objects.all()
+
+ @override_settings(TEST_SWAPPABLE_MODEL="managers_regress.Parent")
+ @isolate_apps("managers_regress")
+ def test_custom_swappable_manager(self):
+ class SwappableModel(models.Model):
+ stuff = models.Manager()
+
+ class Meta:
+ swappable = "TEST_SWAPPABLE_MODEL"
+
+ # Accessing the manager on a swappable model with an
+ # explicit manager should raise an attribute error with a
+ # helpful message
+ msg = (
+ "Manager isn't available; 'managers_regress.SwappableModel' "
+ "has been swapped for 'managers_regress.Parent'"
+ )
+ with self.assertRaisesMessage(AttributeError, msg):
+ SwappableModel.stuff.all()
+
+ @override_settings(TEST_SWAPPABLE_MODEL="managers_regress.Parent")
+ @isolate_apps("managers_regress")
+ def test_explicit_swappable_manager(self):
+ class SwappableModel(models.Model):
+ objects = models.Manager()
+
+ class Meta:
+ swappable = "TEST_SWAPPABLE_MODEL"
+
+ # Accessing the manager on a swappable model with an
+ # explicit manager should raise an attribute error with a
+ # helpful message
+ msg = (
+ "Manager isn't available; 'managers_regress.SwappableModel' "
+ "has been swapped for 'managers_regress.Parent'"
+ )
+ with self.assertRaisesMessage(AttributeError, msg):
+ SwappableModel.objects.all()
+
+ def test_regress_3871(self):
+ related = RelatedModel.objects.create()
+
+ relation = RelationModel()
+ relation.fk = related
+ relation.gfk = related
+ relation.save()
+ relation.m2m.add(related)
+
+ t = Template(
+ "{{ related.test_fk.all.0 }}{{ related.test_gfk.all.0 }}"
+ "{{ related.test_m2m.all.0 }}"
+ )
+
+ self.assertEqual(
+ t.render(Context({"related": related})),
+ "".join([str(relation.pk)] * 3),
+ )
+
+ def test_field_can_be_called_exact(self):
+ # Make sure related managers core filters don't include an
+ # explicit `__exact` lookup that could be interpreted as a
+ # reference to a foreign `exact` field. refs #23940.
+ related = RelatedModel.objects.create(exact=False)
+ relation = related.test_fk.create()
+ self.assertEqual(related.test_fk.get(), relation)
+
+
+@isolate_apps("managers_regress")
+class TestManagerInheritance(SimpleTestCase):
+ def test_implicit_inheritance(self):
+ class CustomManager(models.Manager):
+ pass
+
+ class AbstractModel(models.Model):
+ custom_manager = CustomManager()
+
+ class Meta:
+ abstract = True
+
+ class PlainModel(models.Model):
+ custom_manager = CustomManager()
+
+ self.assertIsInstance(PlainModel._base_manager, models.Manager)
+ self.assertIsInstance(PlainModel._default_manager, CustomManager)
+
+ class ModelWithAbstractParent(AbstractModel):
+ pass
+
+ self.assertIsInstance(ModelWithAbstractParent._base_manager, models.Manager)
+ self.assertIsInstance(ModelWithAbstractParent._default_manager, CustomManager)
+
+ class ProxyModel(PlainModel):
+ class Meta:
+ proxy = True
+
+ self.assertIsInstance(ProxyModel._base_manager, models.Manager)
+ self.assertIsInstance(ProxyModel._default_manager, CustomManager)
+
+ class MTIModel(PlainModel):
+ pass
+
+ self.assertIsInstance(MTIModel._base_manager, models.Manager)
+ self.assertIsInstance(MTIModel._default_manager, CustomManager)
+
+ def test_default_manager_inheritance(self):
+ class CustomManager(models.Manager):
+ pass
+
+ class AbstractModel(models.Model):
+ another_manager = models.Manager()
+ custom_manager = CustomManager()
+
+ class Meta:
+ default_manager_name = "custom_manager"
+ abstract = True
+
+ class PlainModel(models.Model):
+ another_manager = models.Manager()
+ custom_manager = CustomManager()
+
+ class Meta:
+ default_manager_name = "custom_manager"
+
+ self.assertIsInstance(PlainModel._default_manager, CustomManager)
+
+ class ModelWithAbstractParent(AbstractModel):
+ pass
+
+ self.assertIsInstance(ModelWithAbstractParent._default_manager, CustomManager)
+
+ class ProxyModel(PlainModel):
+ class Meta:
+ proxy = True
+
+ self.assertIsInstance(ProxyModel._default_manager, CustomManager)
+
+ class MTIModel(PlainModel):
+ pass
+
+ self.assertIsInstance(MTIModel._default_manager, CustomManager)
+
+ def test_base_manager_inheritance(self):
+ class CustomManager(models.Manager):
+ pass
+
+ class AbstractModel(models.Model):
+ another_manager = models.Manager()
+ custom_manager = CustomManager()
+
+ class Meta:
+ base_manager_name = "custom_manager"
+ abstract = True
+
+ class PlainModel(models.Model):
+ another_manager = models.Manager()
+ custom_manager = CustomManager()
+
+ class Meta:
+ base_manager_name = "custom_manager"
+
+ self.assertIsInstance(PlainModel._base_manager, CustomManager)
+
+ class ModelWithAbstractParent(AbstractModel):
+ pass
+
+ self.assertIsInstance(ModelWithAbstractParent._base_manager, CustomManager)
+
+ class ProxyModel(PlainModel):
+ class Meta:
+ proxy = True
+
+ self.assertIsInstance(ProxyModel._base_manager, CustomManager)
+
+ class MTIModel(PlainModel):
+ pass
+
+ self.assertIsInstance(MTIModel._base_manager, CustomManager)
+
+ def test_manager_no_duplicates(self):
+ class CustomManager(models.Manager):
+ pass
+
+ class AbstractModel(models.Model):
+ custom_manager = models.Manager()
+
+ class Meta:
+ abstract = True
+
+ class TestModel(AbstractModel):
+ custom_manager = CustomManager()
+
+ self.assertEqual(TestModel._meta.managers, (TestModel.custom_manager,))
+ self.assertEqual(
+ TestModel._meta.managers_map, {"custom_manager": TestModel.custom_manager}
+ )
+
+ def test_manager_class_getitem(self):
+ self.assertIs(models.Manager[Child1], models.Manager)
diff --git a/testbed/django__django/tests/many_to_many/__init__.py b/testbed/django__django/tests/many_to_many/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testbed/django__django/tests/many_to_many/models.py b/testbed/django__django/tests/many_to_many/models.py
new file mode 100644
index 0000000000000000000000000000000000000000..541928e94d640bdb1f2ebaf2c260ff2ea24c03ed
--- /dev/null
+++ b/testbed/django__django/tests/many_to_many/models.py
@@ -0,0 +1,79 @@
+"""
+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
diff --git a/testbed/django__django/tests/many_to_many/tests.py b/testbed/django__django/tests/many_to_many/tests.py
new file mode 100644
index 0000000000000000000000000000000000000000..9b43d52c8ab08ba1e1b92c85031c620731f26528
--- /dev/null
+++ b/testbed/django__django/tests/many_to_many/tests.py
@@ -0,0 +1,563 @@
+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 = (
+ '"" 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 "
+ )
+ 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_related_manager_refresh(self):
+ user_1 = User.objects.create(username="Jean")
+ user_2 = User.objects.create(username="Joe")
+ self.a3.authors.add(user_1.username)
+ self.assertSequenceEqual(user_1.article_set.all(), [self.a3])
+ # Change the username on a different instance of the same user.
+ user_1_from_db = User.objects.get(pk=user_1.pk)
+ self.assertSequenceEqual(user_1_from_db.article_set.all(), [self.a3])
+ user_1_from_db.username = "Paul"
+ self.a3.authors.set([user_2.username])
+ user_1_from_db.save()
+ # Assign a different article.
+ self.a4.authors.add(user_1_from_db.username)
+ self.assertSequenceEqual(user_1_from_db.article_set.all(), [self.a4])
+ # Refresh the instance with an evaluated related manager.
+ user_1.refresh_from_db()
+ self.assertEqual(user_1.username, "Paul")
+ self.assertSequenceEqual(user_1.article_set.all(), [self.a4])
+
+ 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_create_after_prefetch(self):
+ a4 = Article.objects.prefetch_related("publications").get(id=self.a4.id)
+ self.assertSequenceEqual(a4.publications.all(), [self.p2])
+ p5 = a4.publications.create(title="Django beats")
+ self.assertCountEqual(a4.publications.all(), [self.p2, p5])
+
+ 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()
+ )
diff --git a/testbed/django__django/tests/many_to_one/__init__.py b/testbed/django__django/tests/many_to_one/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testbed/django__django/tests/many_to_one/models.py b/testbed/django__django/tests/many_to_one/models.py
new file mode 100644
index 0000000000000000000000000000000000000000..cca7e798179f4ddd6f01ecbdeda44959913114d2
--- /dev/null
+++ b/testbed/django__django/tests/many_to_one/models.py
@@ -0,0 +1,132 @@
+"""
+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)
diff --git a/testbed/django__django/tests/many_to_one/tests.py b/testbed/django__django/tests/many_to_one/tests.py
new file mode 100644
index 0000000000000000000000000000000000000000..7a6d112a09d5f2eec2029935105eab3f26ff446e
--- /dev/null
+++ b/testbed/django__django/tests/many_to_one/tests.py
@@ -0,0 +1,879 @@
+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="john@example.com")
+ cls.r.save()
+ cls.r2 = Reporter(
+ first_name="Paul", last_name="Jones", email="paul@example.com"
+ )
+ 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), "")
+
+ 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), "")
+ 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 = (
+ " 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 ")
+ 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), "")
+ 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="royko@suntimes.com"
+ )
+ r2 = Reporter.objects.create(
+ first_name="John", last_name="Kass", email="jkass@tribune.com"
+ )
+ 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)), "")
+
+ 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="john.smith@example.com"
+ )
+ 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 "": "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_parent_after_assign(self):
+ category = Category(name="cats")
+ record = Record(category=category)
+ category.save()
+ record.save()
+ category.name = "dogs"
+ with self.assertNumQueries(0):
+ self.assertEqual(category.id, record.category_id)
+ self.assertEqual(category.name, record.category.name)
+
+ 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()
+ # The reverse foreign key manager can be created.
+ self.assertEqual(th.child_set.model, Third)
+
+ 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])
diff --git a/testbed/django__django/tests/many_to_one_null/__init__.py b/testbed/django__django/tests/many_to_one_null/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testbed/django__django/tests/many_to_one_null/models.py b/testbed/django__django/tests/many_to_one_null/models.py
new file mode 100644
index 0000000000000000000000000000000000000000..a0fcfa6ce5b6bb9123a76a3d7c16ff3b81c73d67
--- /dev/null
+++ b/testbed/django__django/tests/many_to_one_null/models.py
@@ -0,0 +1,33 @@
+"""
+Many-to-one relationships that can be null
+
+To define a many-to-one relationship that can have a null foreign key, use
+``ForeignKey()`` with ``null=True`` .
+"""
+
+from django.db import models
+
+
+class Reporter(models.Model):
+ name = models.CharField(max_length=30)
+
+
+class Article(models.Model):
+ headline = models.CharField(max_length=100)
+ reporter = models.ForeignKey(Reporter, models.SET_NULL, null=True)
+
+ class Meta:
+ ordering = ("headline",)
+
+ def __str__(self):
+ return self.headline
+
+
+class Car(models.Model):
+ make = models.CharField(max_length=100, null=True, unique=True)
+
+
+class Driver(models.Model):
+ car = models.ForeignKey(
+ Car, models.SET_NULL, to_field="make", null=True, related_name="drivers"
+ )
diff --git a/testbed/django__django/tests/many_to_one_null/tests.py b/testbed/django__django/tests/many_to_one_null/tests.py
new file mode 100644
index 0000000000000000000000000000000000000000..f92d49f0a9538c370b8e36e43f8684d8e0219a51
--- /dev/null
+++ b/testbed/django__django/tests/many_to_one_null/tests.py
@@ -0,0 +1,181 @@
+from django.test import TestCase
+
+from .models import Article, Car, Driver, Reporter
+
+
+class ManyToOneNullTests(TestCase):
+ @classmethod
+ def setUpTestData(cls):
+ # Create a Reporter.
+ cls.r = Reporter(name="John Smith")
+ cls.r.save()
+ # Create an Article.
+ cls.a = Article(headline="First", reporter=cls.r)
+ cls.a.save()
+ # Create an Article via the Reporter object.
+ cls.a2 = cls.r.article_set.create(headline="Second")
+ # Create an Article with no Reporter by passing "reporter=None".
+ cls.a3 = Article(headline="Third", reporter=None)
+ cls.a3.save()
+ # Create another article and reporter
+ cls.r2 = Reporter(name="Paul Jones")
+ cls.r2.save()
+ cls.a4 = cls.r2.article_set.create(headline="Fourth")
+
+ def test_get_related(self):
+ self.assertEqual(self.a.reporter.id, self.r.id)
+ # Article objects have access to their related Reporter objects.
+ r = self.a.reporter
+ self.assertEqual(r.id, self.r.id)
+
+ def test_created_via_related_set(self):
+ self.assertEqual(self.a2.reporter.id, self.r.id)
+
+ def test_related_set(self):
+ # Reporter objects have access to their related Article objects.
+ self.assertSequenceEqual(self.r.article_set.all(), [self.a, self.a2])
+ self.assertSequenceEqual(
+ self.r.article_set.filter(headline__startswith="Fir"), [self.a]
+ )
+ self.assertEqual(self.r.article_set.count(), 2)
+
+ def test_created_without_related(self):
+ self.assertIsNone(self.a3.reporter)
+ # Need to reget a3 to refresh the cache
+ a3 = Article.objects.get(pk=self.a3.pk)
+ with self.assertRaises(AttributeError):
+ getattr(a3.reporter, "id")
+ # Accessing an article's 'reporter' attribute returns None
+ # if the reporter is set to None.
+ self.assertIsNone(a3.reporter)
+ # To retrieve the articles with no reporters set, use "reporter__isnull=True".
+ self.assertSequenceEqual(
+ Article.objects.filter(reporter__isnull=True), [self.a3]
+ )
+ # We can achieve the same thing by filtering for the case where the
+ # reporter is None.
+ self.assertSequenceEqual(Article.objects.filter(reporter=None), [self.a3])
+ # Set the reporter for the Third article
+ self.assertSequenceEqual(self.r.article_set.all(), [self.a, self.a2])
+ self.r.article_set.add(a3)
+ self.assertSequenceEqual(
+ self.r.article_set.all(),
+ [self.a, self.a2, self.a3],
+ )
+ # Remove an article from the set, and check that it was removed.
+ self.r.article_set.remove(a3)
+ self.assertSequenceEqual(self.r.article_set.all(), [self.a, self.a2])
+ self.assertSequenceEqual(
+ Article.objects.filter(reporter__isnull=True), [self.a3]
+ )
+
+ def test_remove_from_wrong_set(self):
+ self.assertSequenceEqual(self.r2.article_set.all(), [self.a4])
+ # Try to remove a4 from a set it does not belong to
+ with self.assertRaises(Reporter.DoesNotExist):
+ self.r.article_set.remove(self.a4)
+ self.assertSequenceEqual(self.r2.article_set.all(), [self.a4])
+
+ def test_set(self):
+ # Use manager.set() to allocate ForeignKey. Null is legal, so existing
+ # members of the set that are not in the assignment set are set to null.
+ self.r2.article_set.set([self.a2, self.a3])
+ self.assertSequenceEqual(self.r2.article_set.all(), [self.a2, self.a3])
+ # Use manager.set(clear=True)
+ self.r2.article_set.set([self.a3, self.a4], clear=True)
+ self.assertSequenceEqual(self.r2.article_set.all(), [self.a4, self.a3])
+ # Clear the rest of the set
+ self.r2.article_set.set([])
+ self.assertSequenceEqual(self.r2.article_set.all(), [])
+ self.assertSequenceEqual(
+ Article.objects.filter(reporter__isnull=True),
+ [self.a4, self.a2, self.a3],
+ )
+
+ def test_set_clear_non_bulk(self):
+ # 2 queries for clear(), 1 for add(), and 1 to select objects.
+ with self.assertNumQueries(4):
+ self.r.article_set.set([self.a], bulk=False, clear=True)
+
+ def test_assign_clear_related_set(self):
+ # Use descriptor assignment to allocate ForeignKey. Null is legal, so
+ # existing members of the set that are not in the assignment set are
+ # set to null.
+ self.r2.article_set.set([self.a2, self.a3])
+ self.assertSequenceEqual(self.r2.article_set.all(), [self.a2, self.a3])
+ # Clear the rest of the set
+ self.r.article_set.clear()
+ self.assertSequenceEqual(self.r.article_set.all(), [])
+ self.assertSequenceEqual(
+ Article.objects.filter(reporter__isnull=True),
+ [self.a, self.a4],
+ )
+
+ def test_assign_with_queryset(self):
+ # Querysets used in reverse FK assignments are pre-evaluated
+ # so their value isn't affected by the clearing operation in
+ # RelatedManager.set() (#19816).
+ self.r2.article_set.set([self.a2, self.a3])
+
+ qs = self.r2.article_set.filter(headline="Second")
+ self.r2.article_set.set(qs)
+
+ self.assertEqual(1, self.r2.article_set.count())
+ self.assertEqual(1, qs.count())
+
+ def test_add_efficiency(self):
+ r = Reporter.objects.create()
+ articles = []
+ for _ in range(3):
+ articles.append(Article.objects.create())
+ with self.assertNumQueries(1):
+ r.article_set.add(*articles)
+ self.assertEqual(r.article_set.count(), 3)
+
+ def test_clear_efficiency(self):
+ r = Reporter.objects.create()
+ for _ in range(3):
+ r.article_set.create()
+ with self.assertNumQueries(1):
+ r.article_set.clear()
+ self.assertEqual(r.article_set.count(), 0)
+
+ def test_related_null_to_field(self):
+ c1 = Car.objects.create()
+ d1 = Driver.objects.create()
+ self.assertIs(d1.car, None)
+ with self.assertNumQueries(0):
+ self.assertEqual(list(c1.drivers.all()), [])
+
+ def test_unsaved(self):
+ msg = (
+ "'Car' instance needs to have a primary key value before this relationship "
+ "can be used."
+ )
+ with self.assertRaisesMessage(ValueError, msg):
+ Car(make="Ford").drivers.all()
+
+ def test_related_null_to_field_related_managers(self):
+ car = Car.objects.create(make=None)
+ driver = Driver.objects.create()
+ msg = (
+ f'"{car!r}" needs to have a value for field "make" before this '
+ f"relationship can be used."
+ )
+ with self.assertRaisesMessage(ValueError, msg):
+ car.drivers.add(driver)
+ with self.assertRaisesMessage(ValueError, msg):
+ car.drivers.create()
+ with self.assertRaisesMessage(ValueError, msg):
+ car.drivers.get_or_create()
+ with self.assertRaisesMessage(ValueError, msg):
+ car.drivers.update_or_create()
+ with self.assertRaisesMessage(ValueError, msg):
+ car.drivers.remove(driver)
+ with self.assertRaisesMessage(ValueError, msg):
+ car.drivers.clear()
+ with self.assertRaisesMessage(ValueError, msg):
+ car.drivers.set([driver])
+
+ with self.assertNumQueries(0):
+ self.assertEqual(car.drivers.count(), 0)
diff --git a/testbed/django__django/tests/max_lengths/__init__.py b/testbed/django__django/tests/max_lengths/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testbed/django__django/tests/max_lengths/models.py b/testbed/django__django/tests/max_lengths/models.py
new file mode 100644
index 0000000000000000000000000000000000000000..3a0eee4078058cf783de26076fdaf6909c4396e9
--- /dev/null
+++ b/testbed/django__django/tests/max_lengths/models.py
@@ -0,0 +1,15 @@
+from django.db import models
+
+
+class PersonWithDefaultMaxLengths(models.Model):
+ email = models.EmailField()
+ vcard = models.FileField()
+ homepage = models.URLField()
+ avatar = models.FilePathField()
+
+
+class PersonWithCustomMaxLengths(models.Model):
+ email = models.EmailField(max_length=250)
+ vcard = models.FileField(max_length=250)
+ homepage = models.URLField(max_length=250)
+ avatar = models.FilePathField(max_length=250)
diff --git a/testbed/django__django/tests/max_lengths/tests.py b/testbed/django__django/tests/max_lengths/tests.py
new file mode 100644
index 0000000000000000000000000000000000000000..f2ef8b25d1c2d3df13542c0587742998249a8d25
--- /dev/null
+++ b/testbed/django__django/tests/max_lengths/tests.py
@@ -0,0 +1,40 @@
+import unittest
+
+from django.test import TestCase
+
+from .models import PersonWithCustomMaxLengths, PersonWithDefaultMaxLengths
+
+
+class MaxLengthArgumentsTests(unittest.TestCase):
+ def verify_max_length(self, model, field, length):
+ self.assertEqual(model._meta.get_field(field).max_length, length)
+
+ def test_default_max_lengths(self):
+ self.verify_max_length(PersonWithDefaultMaxLengths, "email", 254)
+ self.verify_max_length(PersonWithDefaultMaxLengths, "vcard", 100)
+ self.verify_max_length(PersonWithDefaultMaxLengths, "homepage", 200)
+ self.verify_max_length(PersonWithDefaultMaxLengths, "avatar", 100)
+
+ def test_custom_max_lengths(self):
+ self.verify_max_length(PersonWithCustomMaxLengths, "email", 250)
+ self.verify_max_length(PersonWithCustomMaxLengths, "vcard", 250)
+ self.verify_max_length(PersonWithCustomMaxLengths, "homepage", 250)
+ self.verify_max_length(PersonWithCustomMaxLengths, "avatar", 250)
+
+
+class MaxLengthORMTests(TestCase):
+ def test_custom_max_lengths(self):
+ args = {
+ "email": "someone@example.com",
+ "vcard": "vcard",
+ "homepage": "http://example.com/",
+ "avatar": "me.jpg",
+ }
+
+ for field in ("email", "vcard", "homepage", "avatar"):
+ new_args = args.copy()
+ new_args[field] = (
+ "X" * 250
+ ) # a value longer than any of the default fields could hold.
+ p = PersonWithCustomMaxLengths.objects.create(**new_args)
+ self.assertEqual(getattr(p, field), ("X" * 250))
diff --git a/testbed/django__django/tests/messages_tests/__init__.py b/testbed/django__django/tests/messages_tests/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testbed/django__django/tests/messages_tests/base.py b/testbed/django__django/tests/messages_tests/base.py
new file mode 100644
index 0000000000000000000000000000000000000000..d89e186278579fdc3403a0327f7c829cd9b8cae6
--- /dev/null
+++ b/testbed/django__django/tests/messages_tests/base.py
@@ -0,0 +1,384 @@
+from django.contrib.messages import constants, get_level, set_level
+from django.contrib.messages.api import MessageFailure
+from django.contrib.messages.constants import DEFAULT_LEVELS
+from django.contrib.messages.storage import default_storage
+from django.contrib.messages.storage.base import Message
+from django.http import HttpRequest, HttpResponse
+from django.test import modify_settings, override_settings
+from django.urls import reverse
+from django.utils.translation import gettext_lazy
+
+
+def add_level_messages(storage):
+ """
+ Add 6 messages from different levels (including a custom one) to a storage
+ instance.
+ """
+ storage.add(constants.INFO, "A generic info message")
+ storage.add(29, "Some custom level")
+ storage.add(constants.DEBUG, "A debugging message", extra_tags="extra-tag")
+ storage.add(constants.WARNING, "A warning")
+ storage.add(constants.ERROR, "An error")
+ storage.add(constants.SUCCESS, "This was a triumph.")
+
+
+class BaseTests:
+ storage_class = default_storage
+ levels = {
+ "debug": constants.DEBUG,
+ "info": constants.INFO,
+ "success": constants.SUCCESS,
+ "warning": constants.WARNING,
+ "error": constants.ERROR,
+ }
+
+ def setUp(self):
+ self.settings_override = override_settings(
+ TEMPLATES=[
+ {
+ "BACKEND": "django.template.backends.django.DjangoTemplates",
+ "DIRS": [],
+ "APP_DIRS": True,
+ "OPTIONS": {
+ "context_processors": (
+ "django.contrib.auth.context_processors.auth",
+ "django.contrib.messages.context_processors.messages",
+ ),
+ },
+ }
+ ],
+ ROOT_URLCONF="messages_tests.urls",
+ MESSAGE_TAGS={},
+ MESSAGE_STORAGE="%s.%s"
+ % (self.storage_class.__module__, self.storage_class.__name__),
+ SESSION_SERIALIZER="django.contrib.sessions.serializers.JSONSerializer",
+ )
+ self.settings_override.enable()
+
+ def tearDown(self):
+ self.settings_override.disable()
+
+ def get_request(self):
+ return HttpRequest()
+
+ def get_response(self):
+ return HttpResponse()
+
+ def get_storage(self, data=None):
+ """
+ Return the storage backend, setting its loaded data to the ``data``
+ argument.
+
+ This method avoids the storage ``_get`` method from getting called so
+ that other parts of the storage backend can be tested independent of
+ the message retrieval logic.
+ """
+ storage = self.storage_class(self.get_request())
+ storage._loaded_data = data or []
+ return storage
+
+ def test_repr(self):
+ request = self.get_request()
+ storage = self.storage_class(request)
+ self.assertEqual(
+ repr(storage),
+ f"<{self.storage_class.__qualname__}: request=>",
+ )
+
+ def test_add(self):
+ storage = self.get_storage()
+ self.assertFalse(storage.added_new)
+ storage.add(constants.INFO, "Test message 1")
+ self.assertTrue(storage.added_new)
+ storage.add(constants.INFO, "Test message 2", extra_tags="tag")
+ self.assertEqual(len(storage), 2)
+
+ def test_add_lazy_translation(self):
+ storage = self.get_storage()
+ response = self.get_response()
+
+ storage.add(constants.INFO, gettext_lazy("lazy message"))
+ storage.update(response)
+
+ storing = self.stored_messages_count(storage, response)
+ self.assertEqual(storing, 1)
+
+ def test_no_update(self):
+ storage = self.get_storage()
+ response = self.get_response()
+ storage.update(response)
+ storing = self.stored_messages_count(storage, response)
+ self.assertEqual(storing, 0)
+
+ def test_add_update(self):
+ storage = self.get_storage()
+ response = self.get_response()
+
+ storage.add(constants.INFO, "Test message 1")
+ storage.add(constants.INFO, "Test message 1", extra_tags="tag")
+ storage.update(response)
+
+ storing = self.stored_messages_count(storage, response)
+ self.assertEqual(storing, 2)
+
+ def test_existing_add_read_update(self):
+ storage = self.get_existing_storage()
+ response = self.get_response()
+
+ storage.add(constants.INFO, "Test message 3")
+ list(storage) # Simulates a read
+ storage.update(response)
+
+ storing = self.stored_messages_count(storage, response)
+ self.assertEqual(storing, 0)
+
+ def test_existing_read_add_update(self):
+ storage = self.get_existing_storage()
+ response = self.get_response()
+
+ list(storage) # Simulates a read
+ storage.add(constants.INFO, "Test message 3")
+ storage.update(response)
+
+ storing = self.stored_messages_count(storage, response)
+ self.assertEqual(storing, 1)
+
+ @override_settings(MESSAGE_LEVEL=constants.DEBUG)
+ def test_full_request_response_cycle(self):
+ """
+ With the message middleware enabled, messages are properly stored and
+ retrieved across the full request/redirect/response cycle.
+ """
+ data = {
+ "messages": ["Test message %d" % x for x in range(5)],
+ }
+ show_url = reverse("show_message")
+ for level in ("debug", "info", "success", "warning", "error"):
+ add_url = reverse("add_message", args=(level,))
+ response = self.client.post(add_url, data, follow=True)
+ self.assertRedirects(response, show_url)
+ self.assertIn("messages", response.context)
+ messages = [Message(self.levels[level], msg) for msg in data["messages"]]
+ self.assertEqual(list(response.context["messages"]), messages)
+ for msg in data["messages"]:
+ self.assertContains(response, msg)
+
+ @override_settings(MESSAGE_LEVEL=constants.DEBUG)
+ def test_with_template_response(self):
+ data = {
+ "messages": ["Test message %d" % x for x in range(5)],
+ }
+ show_url = reverse("show_template_response")
+ for level in self.levels:
+ add_url = reverse("add_template_response", args=(level,))
+ response = self.client.post(add_url, data, follow=True)
+ self.assertRedirects(response, show_url)
+ self.assertIn("messages", response.context)
+ for msg in data["messages"]:
+ self.assertContains(response, msg)
+
+ # there shouldn't be any messages on second GET request
+ response = self.client.get(show_url)
+ for msg in data["messages"]:
+ self.assertNotContains(response, msg)
+
+ def test_context_processor_message_levels(self):
+ show_url = reverse("show_template_response")
+ response = self.client.get(show_url)
+
+ self.assertIn("DEFAULT_MESSAGE_LEVELS", response.context)
+ self.assertEqual(response.context["DEFAULT_MESSAGE_LEVELS"], DEFAULT_LEVELS)
+
+ @override_settings(MESSAGE_LEVEL=constants.DEBUG)
+ def test_multiple_posts(self):
+ """
+ Messages persist properly when multiple POSTs are made before a GET.
+ """
+ data = {
+ "messages": ["Test message %d" % x for x in range(5)],
+ }
+ show_url = reverse("show_message")
+ messages = []
+ for level in ("debug", "info", "success", "warning", "error"):
+ messages.extend(
+ Message(self.levels[level], msg) for msg in data["messages"]
+ )
+ add_url = reverse("add_message", args=(level,))
+ self.client.post(add_url, data)
+ response = self.client.get(show_url)
+ self.assertIn("messages", response.context)
+ self.assertEqual(list(response.context["messages"]), messages)
+ for msg in data["messages"]:
+ self.assertContains(response, msg)
+
+ @modify_settings(
+ INSTALLED_APPS={"remove": "django.contrib.messages"},
+ MIDDLEWARE={"remove": "django.contrib.messages.middleware.MessageMiddleware"},
+ )
+ @override_settings(
+ MESSAGE_LEVEL=constants.DEBUG,
+ TEMPLATES=[
+ {
+ "BACKEND": "django.template.backends.django.DjangoTemplates",
+ "DIRS": [],
+ "APP_DIRS": True,
+ }
+ ],
+ )
+ def test_middleware_disabled(self):
+ """
+ When the middleware is disabled, an exception is raised when one
+ attempts to store a message.
+ """
+ data = {
+ "messages": ["Test message %d" % x for x in range(5)],
+ }
+ reverse("show_message")
+ for level in ("debug", "info", "success", "warning", "error"):
+ add_url = reverse("add_message", args=(level,))
+ with self.assertRaises(MessageFailure):
+ self.client.post(add_url, data, follow=True)
+
+ @modify_settings(
+ INSTALLED_APPS={"remove": "django.contrib.messages"},
+ MIDDLEWARE={"remove": "django.contrib.messages.middleware.MessageMiddleware"},
+ )
+ @override_settings(
+ TEMPLATES=[
+ {
+ "BACKEND": "django.template.backends.django.DjangoTemplates",
+ "DIRS": [],
+ "APP_DIRS": True,
+ }
+ ],
+ )
+ def test_middleware_disabled_fail_silently(self):
+ """
+ When the middleware is disabled, an exception is not raised
+ if 'fail_silently' is True.
+ """
+ data = {
+ "messages": ["Test message %d" % x for x in range(5)],
+ "fail_silently": True,
+ }
+ show_url = reverse("show_message")
+ for level in ("debug", "info", "success", "warning", "error"):
+ add_url = reverse("add_message", args=(level,))
+ response = self.client.post(add_url, data, follow=True)
+ self.assertRedirects(response, show_url)
+ self.assertNotIn("messages", response.context)
+
+ def stored_messages_count(self, storage, response):
+ """
+ Return the number of messages being stored after a
+ ``storage.update()`` call.
+ """
+ raise NotImplementedError("This method must be set by a subclass.")
+
+ def test_get(self):
+ raise NotImplementedError("This method must be set by a subclass.")
+
+ def get_existing_storage(self):
+ return self.get_storage(
+ [
+ Message(constants.INFO, "Test message 1"),
+ Message(constants.INFO, "Test message 2", extra_tags="tag"),
+ ]
+ )
+
+ def test_existing_read(self):
+ """
+ Reading the existing storage doesn't cause the data to be lost.
+ """
+ storage = self.get_existing_storage()
+ self.assertFalse(storage.used)
+ # After iterating the storage engine directly, the used flag is set.
+ data = list(storage)
+ self.assertTrue(storage.used)
+ # The data does not disappear because it has been iterated.
+ self.assertEqual(data, list(storage))
+
+ def test_existing_add(self):
+ storage = self.get_existing_storage()
+ self.assertFalse(storage.added_new)
+ storage.add(constants.INFO, "Test message 3")
+ self.assertTrue(storage.added_new)
+
+ def test_default_level(self):
+ # get_level works even with no storage on the request.
+ request = self.get_request()
+ self.assertEqual(get_level(request), constants.INFO)
+
+ # get_level returns the default level if it hasn't been set.
+ storage = self.get_storage()
+ request._messages = storage
+ self.assertEqual(get_level(request), constants.INFO)
+
+ # Only messages of sufficient level get recorded.
+ add_level_messages(storage)
+ self.assertEqual(len(storage), 5)
+
+ def test_low_level(self):
+ request = self.get_request()
+ storage = self.storage_class(request)
+ request._messages = storage
+
+ self.assertTrue(set_level(request, 5))
+ self.assertEqual(get_level(request), 5)
+
+ add_level_messages(storage)
+ self.assertEqual(len(storage), 6)
+
+ def test_high_level(self):
+ request = self.get_request()
+ storage = self.storage_class(request)
+ request._messages = storage
+
+ self.assertTrue(set_level(request, 30))
+ self.assertEqual(get_level(request), 30)
+
+ add_level_messages(storage)
+ self.assertEqual(len(storage), 2)
+
+ @override_settings(MESSAGE_LEVEL=29)
+ def test_settings_level(self):
+ request = self.get_request()
+ storage = self.storage_class(request)
+
+ self.assertEqual(get_level(request), 29)
+
+ add_level_messages(storage)
+ self.assertEqual(len(storage), 3)
+
+ def test_tags(self):
+ storage = self.get_storage()
+ storage.level = 0
+ add_level_messages(storage)
+ storage.add(constants.INFO, "A generic info message", extra_tags=None)
+ tags = [msg.tags for msg in storage]
+ self.assertEqual(
+ tags, ["info", "", "extra-tag debug", "warning", "error", "success", "info"]
+ )
+
+ def test_level_tag(self):
+ storage = self.get_storage()
+ storage.level = 0
+ add_level_messages(storage)
+ tags = [msg.level_tag for msg in storage]
+ self.assertEqual(tags, ["info", "", "debug", "warning", "error", "success"])
+
+ @override_settings(
+ MESSAGE_TAGS={
+ constants.INFO: "info",
+ constants.DEBUG: "",
+ constants.WARNING: "",
+ constants.ERROR: "bad",
+ 29: "custom",
+ }
+ )
+ def test_custom_tags(self):
+ storage = self.get_storage()
+ storage.level = 0
+ add_level_messages(storage)
+ tags = [msg.tags for msg in storage]
+ self.assertEqual(tags, ["info", "custom", "extra-tag", "", "bad", "success"])
diff --git a/testbed/django__django/tests/messages_tests/models.py b/testbed/django__django/tests/messages_tests/models.py
new file mode 100644
index 0000000000000000000000000000000000000000..8ee894894bcbacf6ab09ee52ff3cb8cceadcb60b
--- /dev/null
+++ b/testbed/django__django/tests/messages_tests/models.py
@@ -0,0 +1,5 @@
+from django.db import models
+
+
+class SomeObject(models.Model):
+ name = models.CharField(max_length=255)
diff --git a/testbed/django__django/tests/messages_tests/test_api.py b/testbed/django__django/tests/messages_tests/test_api.py
new file mode 100644
index 0000000000000000000000000000000000000000..40283d41532916eb1f057a735fa95a3791119b33
--- /dev/null
+++ b/testbed/django__django/tests/messages_tests/test_api.py
@@ -0,0 +1,72 @@
+from django.contrib import messages
+from django.test import RequestFactory, SimpleTestCase
+
+
+class DummyStorage:
+ """
+ dummy message-store to test the api methods
+ """
+
+ def __init__(self):
+ self.store = []
+
+ def add(self, level, message, extra_tags=""):
+ self.store.append(message)
+
+
+class ApiTests(SimpleTestCase):
+ rf = RequestFactory()
+
+ def setUp(self):
+ self.request = self.rf.request()
+ self.storage = DummyStorage()
+
+ def test_ok(self):
+ msg = "some message"
+ self.request._messages = self.storage
+ messages.add_message(self.request, messages.DEBUG, msg)
+ self.assertIn(msg, self.storage.store)
+
+ def test_request_is_none(self):
+ msg = "add_message() argument must be an HttpRequest object, not 'NoneType'."
+ self.request._messages = self.storage
+ with self.assertRaisesMessage(TypeError, msg):
+ messages.add_message(None, messages.DEBUG, "some message")
+ self.assertEqual(self.storage.store, [])
+
+ def test_middleware_missing(self):
+ msg = (
+ "You cannot add messages without installing "
+ "django.contrib.messages.middleware.MessageMiddleware"
+ )
+ with self.assertRaisesMessage(messages.MessageFailure, msg):
+ messages.add_message(self.request, messages.DEBUG, "some message")
+ self.assertEqual(self.storage.store, [])
+
+ def test_middleware_missing_silently(self):
+ messages.add_message(
+ self.request, messages.DEBUG, "some message", fail_silently=True
+ )
+ self.assertEqual(self.storage.store, [])
+
+
+class CustomRequest:
+ def __init__(self, request):
+ self._request = request
+
+ def __getattribute__(self, attr):
+ try:
+ return super().__getattribute__(attr)
+ except AttributeError:
+ return getattr(self._request, attr)
+
+
+class CustomRequestApiTests(ApiTests):
+ """
+ add_message() should use ducktyping to allow request wrappers such as the
+ one in Django REST framework.
+ """
+
+ def setUp(self):
+ super().setUp()
+ self.request = CustomRequest(self.request)
diff --git a/testbed/django__django/tests/messages_tests/test_cookie.py b/testbed/django__django/tests/messages_tests/test_cookie.py
new file mode 100644
index 0000000000000000000000000000000000000000..344df968867f979b46444358439069e20061f4d0
--- /dev/null
+++ b/testbed/django__django/tests/messages_tests/test_cookie.py
@@ -0,0 +1,226 @@
+import json
+import random
+from unittest import TestCase
+
+from django.conf import settings
+from django.contrib.messages import constants
+from django.contrib.messages.storage.base import Message
+from django.contrib.messages.storage.cookie import (
+ CookieStorage,
+ MessageDecoder,
+ MessageEncoder,
+ bisect_keep_left,
+ bisect_keep_right,
+)
+from django.test import SimpleTestCase, override_settings
+from django.utils.crypto import get_random_string
+from django.utils.safestring import SafeData, mark_safe
+
+from .base import BaseTests
+
+
+def set_cookie_data(storage, messages, invalid=False, encode_empty=False):
+ """
+ Set ``request.COOKIES`` with the encoded data and remove the storage
+ backend's loaded data cache.
+ """
+ encoded_data = storage._encode(messages, encode_empty=encode_empty)
+ if invalid:
+ # Truncate the first character so that the hash is invalid.
+ encoded_data = encoded_data[1:]
+ storage.request.COOKIES = {CookieStorage.cookie_name: encoded_data}
+ if hasattr(storage, "_loaded_data"):
+ del storage._loaded_data
+
+
+def stored_cookie_messages_count(storage, response):
+ """
+ Return an integer containing the number of messages stored.
+ """
+ # Get a list of cookies, excluding ones with a max-age of 0 (because
+ # they have been marked for deletion).
+ cookie = response.cookies.get(storage.cookie_name)
+ if not cookie or cookie["max-age"] == 0:
+ return 0
+ data = storage._decode(cookie.value)
+ if not data:
+ return 0
+ if data[-1] == CookieStorage.not_finished:
+ data.pop()
+ return len(data)
+
+
+@override_settings(
+ SESSION_COOKIE_DOMAIN=".example.com",
+ SESSION_COOKIE_SECURE=True,
+ SESSION_COOKIE_HTTPONLY=True,
+)
+class CookieTests(BaseTests, SimpleTestCase):
+ storage_class = CookieStorage
+
+ def stored_messages_count(self, storage, response):
+ return stored_cookie_messages_count(storage, response)
+
+ def encode_decode(self, *args, **kwargs):
+ storage = self.get_storage()
+ message = [Message(constants.DEBUG, *args, **kwargs)]
+ encoded = storage._encode(message)
+ return storage._decode(encoded)[0]
+
+ def test_get(self):
+ storage = self.storage_class(self.get_request())
+ # Set initial data.
+ example_messages = ["test", "me"]
+ set_cookie_data(storage, example_messages)
+ # The message contains what's expected.
+ self.assertEqual(list(storage), example_messages)
+
+ @override_settings(SESSION_COOKIE_SAMESITE="Strict")
+ def test_cookie_settings(self):
+ """
+ CookieStorage honors SESSION_COOKIE_DOMAIN, SESSION_COOKIE_SECURE, and
+ SESSION_COOKIE_HTTPONLY (#15618, #20972).
+ """
+ # Test before the messages have been consumed
+ storage = self.get_storage()
+ response = self.get_response()
+ storage.add(constants.INFO, "test")
+ storage.update(response)
+ messages = storage._decode(response.cookies["messages"].value)
+ self.assertEqual(len(messages), 1)
+ self.assertEqual(messages[0].message, "test")
+ self.assertEqual(response.cookies["messages"]["domain"], ".example.com")
+ self.assertEqual(response.cookies["messages"]["expires"], "")
+ self.assertIs(response.cookies["messages"]["secure"], True)
+ self.assertIs(response.cookies["messages"]["httponly"], True)
+ self.assertEqual(response.cookies["messages"]["samesite"], "Strict")
+
+ # Deletion of the cookie (storing with an empty value) after the
+ # messages have been consumed.
+ storage = self.get_storage()
+ response = self.get_response()
+ storage.add(constants.INFO, "test")
+ for m in storage:
+ pass # Iterate through the storage to simulate consumption of messages.
+ storage.update(response)
+ self.assertEqual(response.cookies["messages"].value, "")
+ self.assertEqual(response.cookies["messages"]["domain"], ".example.com")
+ self.assertEqual(
+ response.cookies["messages"]["expires"], "Thu, 01 Jan 1970 00:00:00 GMT"
+ )
+ self.assertEqual(
+ response.cookies["messages"]["samesite"],
+ settings.SESSION_COOKIE_SAMESITE,
+ )
+
+ def test_get_bad_cookie(self):
+ request = self.get_request()
+ storage = self.storage_class(request)
+ # Set initial (invalid) data.
+ example_messages = ["test", "me"]
+ set_cookie_data(storage, example_messages, invalid=True)
+ # The message actually contains what we expect.
+ self.assertEqual(list(storage), [])
+
+ def test_max_cookie_length(self):
+ """
+ If the data exceeds what is allowed in a cookie, older messages are
+ removed before saving (and returned by the ``update`` method).
+ """
+ storage = self.get_storage()
+ response = self.get_response()
+
+ # When storing as a cookie, the cookie has constant overhead of approx
+ # 54 chars, and each message has a constant overhead of about 37 chars
+ # and a variable overhead of zero in the best case. We aim for a message
+ # size which will fit 4 messages into the cookie, but not 5.
+ # See also FallbackTest.test_session_fallback
+ msg_size = int((CookieStorage.max_cookie_size - 54) / 4.5 - 37)
+ first_msg = None
+ # Generate the same (tested) content every time that does not get run
+ # through zlib compression.
+ random.seed(42)
+ for i in range(5):
+ msg = get_random_string(msg_size)
+ storage.add(constants.INFO, msg)
+ if i == 0:
+ first_msg = msg
+ unstored_messages = storage.update(response)
+
+ cookie_storing = self.stored_messages_count(storage, response)
+ self.assertEqual(cookie_storing, 4)
+
+ self.assertEqual(len(unstored_messages), 1)
+ self.assertEqual(unstored_messages[0].message, first_msg)
+
+ def test_message_rfc6265(self):
+ non_compliant_chars = ["\\", ",", ";", '"']
+ messages = ["\\te,st", ';m"e', "\u2019", '123"NOTRECEIVED"']
+ storage = self.get_storage()
+ encoded = storage._encode(messages)
+ for illegal in non_compliant_chars:
+ self.assertEqual(encoded.find(illegal), -1)
+
+ def test_json_encoder_decoder(self):
+ """
+ A complex nested data structure containing Message
+ instances is properly encoded/decoded by the custom JSON
+ encoder/decoder classes.
+ """
+ messages = [
+ {
+ "message": Message(constants.INFO, "Test message"),
+ "message_list": [
+ Message(constants.INFO, "message %s") for x in range(5)
+ ]
+ + [{"another-message": Message(constants.ERROR, "error")}],
+ },
+ Message(constants.INFO, "message %s"),
+ ]
+ encoder = MessageEncoder()
+ value = encoder.encode(messages)
+ decoded_messages = json.loads(value, cls=MessageDecoder)
+ self.assertEqual(messages, decoded_messages)
+
+ def test_safedata(self):
+ """
+ A message containing SafeData is keeping its safe status when
+ retrieved from the message storage.
+ """
+ self.assertIsInstance(
+ self.encode_decode(mark_safe("Hello Django!")).message,
+ SafeData,
+ )
+ self.assertNotIsInstance(
+ self.encode_decode("Hello Django!").message,
+ SafeData,
+ )
+
+ def test_extra_tags(self):
+ """
+ A message's extra_tags attribute is correctly preserved when retrieved
+ from the message storage.
+ """
+ for extra_tags in ["", None, "some tags"]:
+ with self.subTest(extra_tags=extra_tags):
+ self.assertEqual(
+ self.encode_decode("message", extra_tags=extra_tags).extra_tags,
+ extra_tags,
+ )
+
+
+class BisectTests(TestCase):
+ def test_bisect_keep_left(self):
+ self.assertEqual(bisect_keep_left([1, 1, 1], fn=lambda arr: sum(arr) != 2), 2)
+ self.assertEqual(bisect_keep_left([1, 1, 1], fn=lambda arr: sum(arr) != 0), 0)
+ self.assertEqual(bisect_keep_left([], fn=lambda arr: sum(arr) != 0), 0)
+
+ def test_bisect_keep_right(self):
+ self.assertEqual(bisect_keep_right([1, 1, 1], fn=lambda arr: sum(arr) != 2), 1)
+ self.assertEqual(
+ bisect_keep_right([1, 1, 1, 1], fn=lambda arr: sum(arr) != 2), 2
+ )
+ self.assertEqual(
+ bisect_keep_right([1, 1, 1, 1, 1], fn=lambda arr: sum(arr) != 1), 4
+ )
+ self.assertEqual(bisect_keep_right([], fn=lambda arr: sum(arr) != 0), 0)
diff --git a/testbed/django__django/tests/messages_tests/test_fallback.py b/testbed/django__django/tests/messages_tests/test_fallback.py
new file mode 100644
index 0000000000000000000000000000000000000000..7a335114c52351fd8cdd173af0f5de8107b71443
--- /dev/null
+++ b/testbed/django__django/tests/messages_tests/test_fallback.py
@@ -0,0 +1,159 @@
+import random
+
+from django.contrib.messages import constants
+from django.contrib.messages.storage.fallback import CookieStorage, FallbackStorage
+from django.test import SimpleTestCase
+from django.utils.crypto import get_random_string
+
+from .base import BaseTests
+from .test_cookie import set_cookie_data, stored_cookie_messages_count
+from .test_session import set_session_data, stored_session_messages_count
+
+
+class FallbackTests(BaseTests, SimpleTestCase):
+ storage_class = FallbackStorage
+
+ def get_request(self):
+ self.session = {}
+ request = super().get_request()
+ request.session = self.session
+ return request
+
+ def get_cookie_storage(self, storage):
+ return storage.storages[-2]
+
+ def get_session_storage(self, storage):
+ return storage.storages[-1]
+
+ def stored_cookie_messages_count(self, storage, response):
+ return stored_cookie_messages_count(self.get_cookie_storage(storage), response)
+
+ def stored_session_messages_count(self, storage, response):
+ return stored_session_messages_count(self.get_session_storage(storage))
+
+ def stored_messages_count(self, storage, response):
+ """
+ Return the storage totals from both cookie and session backends.
+ """
+ return self.stored_cookie_messages_count(
+ storage, response
+ ) + self.stored_session_messages_count(storage, response)
+
+ def test_get(self):
+ request = self.get_request()
+ storage = self.storage_class(request)
+ cookie_storage = self.get_cookie_storage(storage)
+ # Set initial cookie data.
+ example_messages = [str(i) for i in range(5)]
+ set_cookie_data(cookie_storage, example_messages)
+ # Overwrite the _get method of the fallback storage to prove it is not
+ # used (it would cause a TypeError: 'NoneType' object is not callable).
+ self.get_session_storage(storage)._get = None
+ self.assertEqual(list(storage), example_messages)
+
+ def test_get_empty(self):
+ request = self.get_request()
+ storage = self.storage_class(request)
+ # Overwrite the _get method of the fallback storage to prove it is not
+ # used (it would cause a TypeError: 'NoneType' object is not callable).
+ self.get_session_storage(storage)._get = None
+ self.assertEqual(list(storage), [])
+
+ def test_get_fallback(self):
+ request = self.get_request()
+ storage = self.storage_class(request)
+ cookie_storage = self.get_cookie_storage(storage)
+ session_storage = self.get_session_storage(storage)
+
+ # Set initial cookie and session data.
+ example_messages = [str(i) for i in range(5)]
+ set_cookie_data(
+ cookie_storage, example_messages[:4] + [CookieStorage.not_finished]
+ )
+ set_session_data(session_storage, example_messages[4:])
+ self.assertEqual(list(storage), example_messages)
+
+ def test_get_fallback_only(self):
+ request = self.get_request()
+ storage = self.storage_class(request)
+ cookie_storage = self.get_cookie_storage(storage)
+ session_storage = self.get_session_storage(storage)
+ # Set initial cookie and session data.
+ example_messages = [str(i) for i in range(5)]
+ set_cookie_data(cookie_storage, [CookieStorage.not_finished], encode_empty=True)
+ set_session_data(session_storage, example_messages)
+ self.assertEqual(list(storage), example_messages)
+
+ def test_flush_used_backends(self):
+ request = self.get_request()
+ storage = self.storage_class(request)
+ cookie_storage = self.get_cookie_storage(storage)
+ session_storage = self.get_session_storage(storage)
+ # Set initial cookie and session data.
+ set_cookie_data(cookie_storage, ["cookie", CookieStorage.not_finished])
+ set_session_data(session_storage, ["session"])
+ # When updating, previously used but no longer needed backends are
+ # flushed.
+ response = self.get_response()
+ list(storage)
+ storage.update(response)
+ session_storing = self.stored_session_messages_count(storage, response)
+ self.assertEqual(session_storing, 0)
+
+ def test_no_fallback(self):
+ """
+ (1) A short number of messages whose data size doesn't exceed what is
+ allowed in a cookie will all be stored in the CookieBackend.
+
+ (2) If the CookieBackend can store all messages, the SessionBackend
+ won't be written to at all.
+ """
+ storage = self.get_storage()
+ response = self.get_response()
+ # Overwrite the _store method of the fallback storage to prove it isn't
+ # used (it would cause a TypeError: 'NoneType' object is not callable).
+ self.get_session_storage(storage)._store = None
+ for i in range(5):
+ storage.add(constants.INFO, str(i) * 100)
+ storage.update(response)
+ cookie_storing = self.stored_cookie_messages_count(storage, response)
+ self.assertEqual(cookie_storing, 5)
+ session_storing = self.stored_session_messages_count(storage, response)
+ self.assertEqual(session_storing, 0)
+
+ def test_session_fallback(self):
+ """
+ If the data exceeds what is allowed in a cookie, messages which did
+ not fit are stored in the SessionBackend.
+ """
+ storage = self.get_storage()
+ response = self.get_response()
+ # see comment in CookieTests.test_cookie_max_length()
+ msg_size = int((CookieStorage.max_cookie_size - 54) / 4.5 - 37)
+ # Generate the same (tested) content every time that does not get run
+ # through zlib compression.
+ random.seed(42)
+ for i in range(5):
+ storage.add(constants.INFO, get_random_string(msg_size))
+ storage.update(response)
+ cookie_storing = self.stored_cookie_messages_count(storage, response)
+ self.assertEqual(cookie_storing, 4)
+ session_storing = self.stored_session_messages_count(storage, response)
+ self.assertEqual(session_storing, 1)
+
+ def test_session_fallback_only(self):
+ """
+ Large messages, none of which fit in a cookie, are stored in the
+ SessionBackend (and nothing is stored in the CookieBackend).
+ """
+ storage = self.get_storage()
+ response = self.get_response()
+ # Generate the same (tested) content every time that does not get run
+ # through zlib compression.
+ random.seed(42)
+ storage.add(constants.INFO, get_random_string(5000))
+ storage.update(response)
+ cookie_storing = self.stored_cookie_messages_count(storage, response)
+ self.assertEqual(cookie_storing, 0)
+ session_storing = self.stored_session_messages_count(storage, response)
+ self.assertEqual(session_storing, 1)
diff --git a/testbed/django__django/tests/messages_tests/test_middleware.py b/testbed/django__django/tests/messages_tests/test_middleware.py
new file mode 100644
index 0000000000000000000000000000000000000000..6b5733fdd2cc81afec91f52932799aae4fcce194
--- /dev/null
+++ b/testbed/django__django/tests/messages_tests/test_middleware.py
@@ -0,0 +1,16 @@
+import unittest
+
+from django.contrib.messages.middleware import MessageMiddleware
+from django.http import HttpRequest, HttpResponse
+
+
+class MiddlewareTests(unittest.TestCase):
+ def test_response_without_messages(self):
+ """
+ MessageMiddleware is tolerant of messages not existing on request.
+ """
+ request = HttpRequest()
+ response = HttpResponse()
+ MessageMiddleware(lambda req: HttpResponse()).process_response(
+ request, response
+ )
diff --git a/testbed/django__django/tests/messages_tests/test_mixins.py b/testbed/django__django/tests/messages_tests/test_mixins.py
new file mode 100644
index 0000000000000000000000000000000000000000..0e3e0360d999060cc228e6928212d2f1227ab022
--- /dev/null
+++ b/testbed/django__django/tests/messages_tests/test_mixins.py
@@ -0,0 +1,25 @@
+from django.core.signing import b64_decode
+from django.test import TestCase, override_settings
+from django.urls import reverse
+
+from .models import SomeObject
+from .urls import ContactFormViewWithMsg, DeleteFormViewWithMsg
+
+
+@override_settings(ROOT_URLCONF="messages_tests.urls")
+class SuccessMessageMixinTests(TestCase):
+ def test_set_messages_success(self):
+ author = {"name": "John Doe", "slug": "success-msg"}
+ add_url = reverse("add_success_msg")
+ req = self.client.post(add_url, author)
+ # Uncompressed message is stored in the cookie.
+ value = b64_decode(
+ req.cookies["messages"].value.split(":")[0].encode(),
+ ).decode()
+ self.assertIn(ContactFormViewWithMsg.success_message % author, value)
+
+ def test_set_messages_success_on_delete(self):
+ object_to_delete = SomeObject.objects.create(name="MyObject")
+ delete_url = reverse("success_msg_on_delete", args=[object_to_delete.pk])
+ response = self.client.post(delete_url, follow=True)
+ self.assertContains(response, DeleteFormViewWithMsg.success_message)
diff --git a/testbed/django__django/tests/messages_tests/test_session.py b/testbed/django__django/tests/messages_tests/test_session.py
new file mode 100644
index 0000000000000000000000000000000000000000..07be6063f7a94c43aed8594688f55d4da313576a
--- /dev/null
+++ b/testbed/django__django/tests/messages_tests/test_session.py
@@ -0,0 +1,64 @@
+from django.contrib.messages import constants
+from django.contrib.messages.storage.base import Message
+from django.contrib.messages.storage.session import SessionStorage
+from django.core.exceptions import ImproperlyConfigured
+from django.http import HttpRequest
+from django.test import TestCase
+from django.utils.safestring import SafeData, mark_safe
+
+from .base import BaseTests
+
+
+def set_session_data(storage, messages):
+ """
+ Sets the messages into the backend request's session and remove the
+ backend's loaded data cache.
+ """
+ storage.request.session[storage.session_key] = storage.serialize_messages(messages)
+ if hasattr(storage, "_loaded_data"):
+ del storage._loaded_data
+
+
+def stored_session_messages_count(storage):
+ data = storage.deserialize_messages(
+ storage.request.session.get(storage.session_key, [])
+ )
+ return len(data)
+
+
+class SessionTests(BaseTests, TestCase):
+ storage_class = SessionStorage
+
+ def get_request(self):
+ self.session = {}
+ request = super().get_request()
+ request.session = self.session
+ return request
+
+ def stored_messages_count(self, storage, response):
+ return stored_session_messages_count(storage)
+
+ def test_no_session(self):
+ msg = (
+ "The session-based temporary message storage requires session "
+ "middleware to be installed, and come before the message "
+ "middleware in the MIDDLEWARE list."
+ )
+ with self.assertRaisesMessage(ImproperlyConfigured, msg):
+ self.storage_class(HttpRequest())
+
+ def test_get(self):
+ storage = self.storage_class(self.get_request())
+ example_messages = ["test", "me"]
+ set_session_data(storage, example_messages)
+ self.assertEqual(list(storage), example_messages)
+
+ def test_safedata(self):
+ """
+ A message containing SafeData keeps its safe status when retrieved from
+ the message storage.
+ """
+ storage = self.get_storage()
+ message = Message(constants.DEBUG, mark_safe("Hello Django!"))
+ set_session_data(storage, [message])
+ self.assertIsInstance(list(storage)[0].message, SafeData)
diff --git a/testbed/django__django/tests/messages_tests/tests.py b/testbed/django__django/tests/messages_tests/tests.py
new file mode 100644
index 0000000000000000000000000000000000000000..d16854a89a441bd485b2a0c6c821f1a3b4ef08f0
--- /dev/null
+++ b/testbed/django__django/tests/messages_tests/tests.py
@@ -0,0 +1,33 @@
+from unittest import mock
+
+from django.contrib.messages import constants
+from django.contrib.messages.storage import base
+from django.contrib.messages.storage.base import Message
+from django.test import SimpleTestCase, override_settings
+
+
+class MessageTests(SimpleTestCase):
+ def test_eq(self):
+ msg_1 = Message(constants.INFO, "Test message 1")
+ msg_2 = Message(constants.INFO, "Test message 2")
+ msg_3 = Message(constants.WARNING, "Test message 1")
+ self.assertEqual(msg_1, msg_1)
+ self.assertEqual(msg_1, mock.ANY)
+ self.assertNotEqual(msg_1, msg_2)
+ self.assertNotEqual(msg_1, msg_3)
+ self.assertNotEqual(msg_2, msg_3)
+
+
+class TestLevelTags(SimpleTestCase):
+ message_tags = {
+ constants.INFO: "info",
+ constants.DEBUG: "",
+ constants.WARNING: "",
+ constants.ERROR: "bad",
+ constants.SUCCESS: "",
+ 12: "custom",
+ }
+
+ @override_settings(MESSAGE_TAGS=message_tags)
+ def test_override_settings_level_tags(self):
+ self.assertEqual(base.LEVEL_TAGS, self.message_tags)
diff --git a/testbed/django__django/tests/messages_tests/urls.py b/testbed/django__django/tests/messages_tests/urls.py
new file mode 100644
index 0000000000000000000000000000000000000000..3f70911d4f57cac14417754a291e4c7dd4229a2d
--- /dev/null
+++ b/testbed/django__django/tests/messages_tests/urls.py
@@ -0,0 +1,91 @@
+from django import forms
+from django.contrib import messages
+from django.contrib.messages.views import SuccessMessageMixin
+from django.http import HttpResponse, HttpResponseRedirect
+from django.template import engines
+from django.template.response import TemplateResponse
+from django.urls import path, re_path, reverse
+from django.views.decorators.cache import never_cache
+from django.views.generic.edit import DeleteView, FormView
+
+from .models import SomeObject
+
+TEMPLATE = """{% if messages %}
+
+ {% for message in messages %}
+
+ {{ message }}
+
+ {% endfor %}
+
+{% endif %}
+"""
+
+
+@never_cache
+def add(request, message_type):
+ # Don't default to False here to test that it defaults to False if
+ # unspecified.
+ fail_silently = request.POST.get("fail_silently", None)
+ for msg in request.POST.getlist("messages"):
+ if fail_silently is not None:
+ getattr(messages, message_type)(request, msg, fail_silently=fail_silently)
+ else:
+ getattr(messages, message_type)(request, msg)
+ return HttpResponseRedirect(reverse("show_message"))
+
+
+@never_cache
+def add_template_response(request, message_type):
+ for msg in request.POST.getlist("messages"):
+ getattr(messages, message_type)(request, msg)
+ return HttpResponseRedirect(reverse("show_template_response"))
+
+
+@never_cache
+def show(request):
+ template = engines["django"].from_string(TEMPLATE)
+ return HttpResponse(template.render(request=request))
+
+
+@never_cache
+def show_template_response(request):
+ template = engines["django"].from_string(TEMPLATE)
+ return TemplateResponse(request, template)
+
+
+class ContactForm(forms.Form):
+ name = forms.CharField(required=True)
+ slug = forms.SlugField(required=True)
+
+
+class ContactFormViewWithMsg(SuccessMessageMixin, FormView):
+ form_class = ContactForm
+ success_url = show
+ success_message = "%(name)s was created successfully"
+
+
+class DeleteFormViewWithMsg(SuccessMessageMixin, DeleteView):
+ model = SomeObject
+ success_url = "/show/"
+ success_message = "Object was deleted successfully"
+
+
+urlpatterns = [
+ re_path("^add/(debug|info|success|warning|error)/$", add, name="add_message"),
+ path("add/msg/", ContactFormViewWithMsg.as_view(), name="add_success_msg"),
+ path(
+ "delete/msg/",
+ DeleteFormViewWithMsg.as_view(),
+ name="success_msg_on_delete",
+ ),
+ path("show/", show, name="show_message"),
+ re_path(
+ "^template_response/add/(debug|info|success|warning|error)/$",
+ add_template_response,
+ name="add_template_response",
+ ),
+ path(
+ "template_response/show/", show_template_response, name="show_template_response"
+ ),
+]
diff --git a/testbed/django__django/tests/middleware/__init__.py b/testbed/django__django/tests/middleware/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testbed/django__django/tests/middleware/cond_get_urls.py b/testbed/django__django/tests/middleware/cond_get_urls.py
new file mode 100644
index 0000000000000000000000000000000000000000..884ef6ad38b66d91ad9e926e0360e288420f4ed3
--- /dev/null
+++ b/testbed/django__django/tests/middleware/cond_get_urls.py
@@ -0,0 +1,6 @@
+from django.http import HttpResponse
+from django.urls import path
+
+urlpatterns = [
+ path("", lambda request: HttpResponse("root is here")),
+]
diff --git a/testbed/django__django/tests/middleware/extra_urls.py b/testbed/django__django/tests/middleware/extra_urls.py
new file mode 100644
index 0000000000000000000000000000000000000000..faa6ed9f4c1ef316ce93d07fb2e48a4c2a960b6a
--- /dev/null
+++ b/testbed/django__django/tests/middleware/extra_urls.py
@@ -0,0 +1,9 @@
+from django.urls import path
+
+from . import views
+
+urlpatterns = [
+ path("customurlconf/noslash", views.empty_view),
+ path("customurlconf/slash/", views.empty_view),
+ path("customurlconf/needsquoting#/", views.empty_view),
+]
diff --git a/testbed/django__django/tests/middleware/test_security.py b/testbed/django__django/tests/middleware/test_security.py
new file mode 100644
index 0000000000000000000000000000000000000000..dd220b8f4c3df9b47d231402f035bdcb11e2272c
--- /dev/null
+++ b/testbed/django__django/tests/middleware/test_security.py
@@ -0,0 +1,307 @@
+from django.http import HttpResponse
+from django.test import RequestFactory, SimpleTestCase
+from django.test.utils import override_settings
+
+
+class SecurityMiddlewareTest(SimpleTestCase):
+ def middleware(self, *args, **kwargs):
+ from django.middleware.security import SecurityMiddleware
+
+ return SecurityMiddleware(self.response(*args, **kwargs))
+
+ @property
+ def secure_request_kwargs(self):
+ return {"wsgi.url_scheme": "https"}
+
+ def response(self, *args, headers=None, **kwargs):
+ def get_response(req):
+ response = HttpResponse(*args, **kwargs)
+ if headers:
+ for k, v in headers.items():
+ response.headers[k] = v
+ return response
+
+ return get_response
+
+ def process_response(self, *args, secure=False, request=None, **kwargs):
+ request_kwargs = {}
+ if secure:
+ request_kwargs.update(self.secure_request_kwargs)
+ if request is None:
+ request = self.request.get("/some/url", **request_kwargs)
+ ret = self.middleware(*args, **kwargs).process_request(request)
+ if ret:
+ return ret
+ return self.middleware(*args, **kwargs)(request)
+
+ request = RequestFactory()
+
+ def process_request(self, method, *args, secure=False, **kwargs):
+ if secure:
+ kwargs.update(self.secure_request_kwargs)
+ req = getattr(self.request, method.lower())(*args, **kwargs)
+ return self.middleware().process_request(req)
+
+ @override_settings(SECURE_HSTS_SECONDS=3600)
+ def test_sts_on(self):
+ """
+ With SECURE_HSTS_SECONDS=3600, the middleware adds
+ "Strict-Transport-Security: max-age=3600" to the response.
+ """
+ self.assertEqual(
+ self.process_response(secure=True).headers["Strict-Transport-Security"],
+ "max-age=3600",
+ )
+
+ @override_settings(SECURE_HSTS_SECONDS=3600)
+ def test_sts_already_present(self):
+ """
+ The middleware will not override a "Strict-Transport-Security" header
+ already present in the response.
+ """
+ response = self.process_response(
+ secure=True, headers={"Strict-Transport-Security": "max-age=7200"}
+ )
+ self.assertEqual(response.headers["Strict-Transport-Security"], "max-age=7200")
+
+ @override_settings(SECURE_HSTS_SECONDS=3600)
+ def test_sts_only_if_secure(self):
+ """
+ The "Strict-Transport-Security" header is not added to responses going
+ over an insecure connection.
+ """
+ self.assertNotIn(
+ "Strict-Transport-Security",
+ self.process_response(secure=False).headers,
+ )
+
+ @override_settings(SECURE_HSTS_SECONDS=0)
+ def test_sts_off(self):
+ """
+ With SECURE_HSTS_SECONDS=0, the middleware does not add a
+ "Strict-Transport-Security" header to the response.
+ """
+ self.assertNotIn(
+ "Strict-Transport-Security",
+ self.process_response(secure=True).headers,
+ )
+
+ @override_settings(SECURE_HSTS_SECONDS=600, SECURE_HSTS_INCLUDE_SUBDOMAINS=True)
+ def test_sts_include_subdomains(self):
+ """
+ With SECURE_HSTS_SECONDS non-zero and SECURE_HSTS_INCLUDE_SUBDOMAINS
+ True, the middleware adds a "Strict-Transport-Security" header with the
+ "includeSubDomains" directive to the response.
+ """
+ response = self.process_response(secure=True)
+ self.assertEqual(
+ response.headers["Strict-Transport-Security"],
+ "max-age=600; includeSubDomains",
+ )
+
+ @override_settings(SECURE_HSTS_SECONDS=600, SECURE_HSTS_INCLUDE_SUBDOMAINS=False)
+ def test_sts_no_include_subdomains(self):
+ """
+ With SECURE_HSTS_SECONDS non-zero and SECURE_HSTS_INCLUDE_SUBDOMAINS
+ False, the middleware adds a "Strict-Transport-Security" header without
+ the "includeSubDomains" directive to the response.
+ """
+ response = self.process_response(secure=True)
+ self.assertEqual(response.headers["Strict-Transport-Security"], "max-age=600")
+
+ @override_settings(SECURE_HSTS_SECONDS=10886400, SECURE_HSTS_PRELOAD=True)
+ def test_sts_preload(self):
+ """
+ With SECURE_HSTS_SECONDS non-zero and SECURE_HSTS_PRELOAD True, the
+ middleware adds a "Strict-Transport-Security" header with the "preload"
+ directive to the response.
+ """
+ response = self.process_response(secure=True)
+ self.assertEqual(
+ response.headers["Strict-Transport-Security"],
+ "max-age=10886400; preload",
+ )
+
+ @override_settings(
+ SECURE_HSTS_SECONDS=10886400,
+ SECURE_HSTS_INCLUDE_SUBDOMAINS=True,
+ SECURE_HSTS_PRELOAD=True,
+ )
+ def test_sts_subdomains_and_preload(self):
+ """
+ With SECURE_HSTS_SECONDS non-zero, SECURE_HSTS_INCLUDE_SUBDOMAINS and
+ SECURE_HSTS_PRELOAD True, the middleware adds a "Strict-Transport-Security"
+ header containing both the "includeSubDomains" and "preload" directives
+ to the response.
+ """
+ response = self.process_response(secure=True)
+ self.assertEqual(
+ response.headers["Strict-Transport-Security"],
+ "max-age=10886400; includeSubDomains; preload",
+ )
+
+ @override_settings(SECURE_HSTS_SECONDS=10886400, SECURE_HSTS_PRELOAD=False)
+ def test_sts_no_preload(self):
+ """
+ With SECURE_HSTS_SECONDS non-zero and SECURE_HSTS_PRELOAD
+ False, the middleware adds a "Strict-Transport-Security" header without
+ the "preload" directive to the response.
+ """
+ response = self.process_response(secure=True)
+ self.assertEqual(
+ response.headers["Strict-Transport-Security"],
+ "max-age=10886400",
+ )
+
+ @override_settings(SECURE_CONTENT_TYPE_NOSNIFF=True)
+ def test_content_type_on(self):
+ """
+ With SECURE_CONTENT_TYPE_NOSNIFF set to True, the middleware adds
+ "X-Content-Type-Options: nosniff" header to the response.
+ """
+ self.assertEqual(
+ self.process_response().headers["X-Content-Type-Options"],
+ "nosniff",
+ )
+
+ @override_settings(SECURE_CONTENT_TYPE_NOSNIFF=True)
+ def test_content_type_already_present(self):
+ """
+ The middleware will not override an "X-Content-Type-Options" header
+ already present in the response.
+ """
+ response = self.process_response(
+ secure=True, headers={"X-Content-Type-Options": "foo"}
+ )
+ self.assertEqual(response.headers["X-Content-Type-Options"], "foo")
+
+ @override_settings(SECURE_CONTENT_TYPE_NOSNIFF=False)
+ def test_content_type_off(self):
+ """
+ With SECURE_CONTENT_TYPE_NOSNIFF False, the middleware does not add an
+ "X-Content-Type-Options" header to the response.
+ """
+ self.assertNotIn("X-Content-Type-Options", self.process_response().headers)
+
+ @override_settings(SECURE_SSL_REDIRECT=True)
+ def test_ssl_redirect_on(self):
+ """
+ With SECURE_SSL_REDIRECT True, the middleware redirects any non-secure
+ requests to the https:// version of the same URL.
+ """
+ ret = self.process_request("get", "/some/url?query=string")
+ self.assertEqual(ret.status_code, 301)
+ self.assertEqual(ret["Location"], "https://testserver/some/url?query=string")
+
+ @override_settings(SECURE_SSL_REDIRECT=True)
+ def test_no_redirect_ssl(self):
+ """
+ The middleware does not redirect secure requests.
+ """
+ ret = self.process_request("get", "/some/url", secure=True)
+ self.assertIsNone(ret)
+
+ @override_settings(SECURE_SSL_REDIRECT=True, SECURE_REDIRECT_EXEMPT=["^insecure/"])
+ def test_redirect_exempt(self):
+ """
+ The middleware does not redirect requests with URL path matching an
+ exempt pattern.
+ """
+ ret = self.process_request("get", "/insecure/page")
+ self.assertIsNone(ret)
+
+ @override_settings(SECURE_SSL_REDIRECT=True, SECURE_SSL_HOST="secure.example.com")
+ def test_redirect_ssl_host(self):
+ """
+ The middleware redirects to SECURE_SSL_HOST if given.
+ """
+ ret = self.process_request("get", "/some/url")
+ self.assertEqual(ret.status_code, 301)
+ self.assertEqual(ret["Location"], "https://secure.example.com/some/url")
+
+ @override_settings(SECURE_SSL_REDIRECT=False)
+ def test_ssl_redirect_off(self):
+ """
+ With SECURE_SSL_REDIRECT False, the middleware does not redirect.
+ """
+ ret = self.process_request("get", "/some/url")
+ self.assertIsNone(ret)
+
+ @override_settings(SECURE_REFERRER_POLICY=None)
+ def test_referrer_policy_off(self):
+ """
+ With SECURE_REFERRER_POLICY set to None, the middleware does not add a
+ "Referrer-Policy" header to the response.
+ """
+ self.assertNotIn("Referrer-Policy", self.process_response().headers)
+
+ def test_referrer_policy_on(self):
+ """
+ With SECURE_REFERRER_POLICY set to a valid value, the middleware adds a
+ "Referrer-Policy" header to the response.
+ """
+ tests = (
+ ("strict-origin", "strict-origin"),
+ ("strict-origin,origin", "strict-origin,origin"),
+ ("strict-origin, origin", "strict-origin,origin"),
+ (["strict-origin", "origin"], "strict-origin,origin"),
+ (("strict-origin", "origin"), "strict-origin,origin"),
+ )
+ for value, expected in tests:
+ with self.subTest(value=value), override_settings(
+ SECURE_REFERRER_POLICY=value
+ ):
+ self.assertEqual(
+ self.process_response().headers["Referrer-Policy"],
+ expected,
+ )
+
+ @override_settings(SECURE_REFERRER_POLICY="strict-origin")
+ def test_referrer_policy_already_present(self):
+ """
+ The middleware will not override a "Referrer-Policy" header already
+ present in the response.
+ """
+ response = self.process_response(headers={"Referrer-Policy": "unsafe-url"})
+ self.assertEqual(response.headers["Referrer-Policy"], "unsafe-url")
+
+ @override_settings(SECURE_CROSS_ORIGIN_OPENER_POLICY=None)
+ def test_coop_off(self):
+ """
+ With SECURE_CROSS_ORIGIN_OPENER_POLICY set to None, the middleware does
+ not add a "Cross-Origin-Opener-Policy" header to the response.
+ """
+ self.assertNotIn("Cross-Origin-Opener-Policy", self.process_response())
+
+ def test_coop_default(self):
+ """SECURE_CROSS_ORIGIN_OPENER_POLICY defaults to same-origin."""
+ self.assertEqual(
+ self.process_response().headers["Cross-Origin-Opener-Policy"],
+ "same-origin",
+ )
+
+ def test_coop_on(self):
+ """
+ With SECURE_CROSS_ORIGIN_OPENER_POLICY set to a valid value, the
+ middleware adds a "Cross-Origin_Opener-Policy" header to the response.
+ """
+ tests = ["same-origin", "same-origin-allow-popups", "unsafe-none"]
+ for value in tests:
+ with self.subTest(value=value), override_settings(
+ SECURE_CROSS_ORIGIN_OPENER_POLICY=value,
+ ):
+ self.assertEqual(
+ self.process_response().headers["Cross-Origin-Opener-Policy"],
+ value,
+ )
+
+ @override_settings(SECURE_CROSS_ORIGIN_OPENER_POLICY="unsafe-none")
+ def test_coop_already_present(self):
+ """
+ The middleware doesn't override a "Cross-Origin-Opener-Policy" header
+ already present in the response.
+ """
+ response = self.process_response(
+ headers={"Cross-Origin-Opener-Policy": "same-origin"}
+ )
+ self.assertEqual(response.headers["Cross-Origin-Opener-Policy"], "same-origin")
diff --git a/testbed/django__django/tests/middleware/tests.py b/testbed/django__django/tests/middleware/tests.py
new file mode 100644
index 0000000000000000000000000000000000000000..2153a0bb5a699dd82cd2cd5ab6e3464a1f11a781
--- /dev/null
+++ b/testbed/django__django/tests/middleware/tests.py
@@ -0,0 +1,1099 @@
+import gzip
+import random
+import re
+import struct
+from io import BytesIO
+from unittest import mock
+from urllib.parse import quote
+
+from django.conf import settings
+from django.core import mail
+from django.core.exceptions import PermissionDenied
+from django.http import (
+ FileResponse,
+ HttpRequest,
+ HttpResponse,
+ HttpResponseNotFound,
+ HttpResponsePermanentRedirect,
+ HttpResponseRedirect,
+ StreamingHttpResponse,
+)
+from django.middleware.clickjacking import XFrameOptionsMiddleware
+from django.middleware.common import BrokenLinkEmailsMiddleware, CommonMiddleware
+from django.middleware.gzip import GZipMiddleware
+from django.middleware.http import ConditionalGetMiddleware
+from django.test import RequestFactory, SimpleTestCase, override_settings
+
+int2byte = struct.Struct(">B").pack
+
+
+def get_response_empty(request):
+ return HttpResponse()
+
+
+def get_response_404(request):
+ return HttpResponseNotFound()
+
+
+@override_settings(ROOT_URLCONF="middleware.urls")
+class CommonMiddlewareTest(SimpleTestCase):
+ rf = RequestFactory()
+
+ @override_settings(APPEND_SLASH=True)
+ def test_append_slash_have_slash(self):
+ """
+ URLs with slashes should go unmolested.
+ """
+ request = self.rf.get("/slash/")
+ self.assertIsNone(CommonMiddleware(get_response_404).process_request(request))
+ self.assertEqual(CommonMiddleware(get_response_404)(request).status_code, 404)
+
+ @override_settings(APPEND_SLASH=True)
+ def test_append_slash_slashless_resource(self):
+ """
+ Matches to explicit slashless URLs should go unmolested.
+ """
+
+ def get_response(req):
+ return HttpResponse("Here's the text of the web page.")
+
+ request = self.rf.get("/noslash")
+ self.assertIsNone(CommonMiddleware(get_response).process_request(request))
+ self.assertEqual(
+ CommonMiddleware(get_response)(request).content,
+ b"Here's the text of the web page.",
+ )
+
+ @override_settings(APPEND_SLASH=True)
+ def test_append_slash_slashless_unknown(self):
+ """
+ APPEND_SLASH should not redirect to unknown resources.
+ """
+ request = self.rf.get("/unknown")
+ response = CommonMiddleware(get_response_404)(request)
+ self.assertEqual(response.status_code, 404)
+
+ @override_settings(APPEND_SLASH=True)
+ def test_append_slash_redirect(self):
+ """
+ APPEND_SLASH should redirect slashless URLs to a valid pattern.
+ """
+ request = self.rf.get("/slash")
+ r = CommonMiddleware(get_response_empty).process_request(request)
+ self.assertIsNone(r)
+ response = HttpResponseNotFound()
+ r = CommonMiddleware(get_response_empty).process_response(request, response)
+ self.assertEqual(r.status_code, 301)
+ self.assertEqual(r.url, "/slash/")
+
+ @override_settings(APPEND_SLASH=True)
+ def test_append_slash_redirect_querystring(self):
+ """
+ APPEND_SLASH should preserve querystrings when redirecting.
+ """
+ request = self.rf.get("/slash?test=1")
+ resp = CommonMiddleware(get_response_404)(request)
+ self.assertEqual(resp.url, "/slash/?test=1")
+
+ @override_settings(APPEND_SLASH=True)
+ def test_append_slash_redirect_querystring_have_slash(self):
+ """
+ APPEND_SLASH should append slash to path when redirecting a request
+ with a querystring ending with slash.
+ """
+ request = self.rf.get("/slash?test=slash/")
+ resp = CommonMiddleware(get_response_404)(request)
+ self.assertIsInstance(resp, HttpResponsePermanentRedirect)
+ self.assertEqual(resp.url, "/slash/?test=slash/")
+
+ @override_settings(APPEND_SLASH=True, DEBUG=True)
+ def test_append_slash_no_redirect_on_POST_in_DEBUG(self):
+ """
+ While in debug mode, an exception is raised with a warning
+ when a failed attempt is made to POST, PUT, or PATCH to an URL which
+ would normally be redirected to a slashed version.
+ """
+ msg = "maintaining %s data. Change your form to point to testserver/slash/"
+ request = self.rf.get("/slash")
+ request.method = "POST"
+ with self.assertRaisesMessage(RuntimeError, msg % request.method):
+ CommonMiddleware(get_response_404)(request)
+ request = self.rf.get("/slash")
+ request.method = "PUT"
+ with self.assertRaisesMessage(RuntimeError, msg % request.method):
+ CommonMiddleware(get_response_404)(request)
+ request = self.rf.get("/slash")
+ request.method = "PATCH"
+ with self.assertRaisesMessage(RuntimeError, msg % request.method):
+ CommonMiddleware(get_response_404)(request)
+
+ @override_settings(APPEND_SLASH=False)
+ def test_append_slash_disabled(self):
+ """
+ Disabling append slash functionality should leave slashless URLs alone.
+ """
+ request = self.rf.get("/slash")
+ self.assertEqual(CommonMiddleware(get_response_404)(request).status_code, 404)
+
+ @override_settings(APPEND_SLASH=True)
+ def test_append_slash_opt_out(self):
+ """
+ Views marked with @no_append_slash should be left alone.
+ """
+ request = self.rf.get("/sensitive_fbv")
+ self.assertEqual(CommonMiddleware(get_response_404)(request).status_code, 404)
+
+ request = self.rf.get("/sensitive_cbv")
+ self.assertEqual(CommonMiddleware(get_response_404)(request).status_code, 404)
+
+ @override_settings(APPEND_SLASH=True)
+ def test_append_slash_quoted(self):
+ """
+ URLs which require quoting should be redirected to their slash version.
+ """
+ request = self.rf.get(quote("/needsquoting#"))
+ r = CommonMiddleware(get_response_404)(request)
+ self.assertEqual(r.status_code, 301)
+ self.assertEqual(r.url, "/needsquoting%23/")
+
+ @override_settings(APPEND_SLASH=True)
+ def test_append_slash_leading_slashes(self):
+ """
+ Paths starting with two slashes are escaped to prevent open redirects.
+ If there's a URL pattern that allows paths to start with two slashes, a
+ request with path //evil.com must not redirect to //evil.com/ (appended
+ slash) which is a schemaless absolute URL. The browser would navigate
+ to evil.com/.
+ """
+ # Use 4 slashes because of RequestFactory behavior.
+ request = self.rf.get("////evil.com/security")
+ r = CommonMiddleware(get_response_404).process_request(request)
+ self.assertIsNone(r)
+ response = HttpResponseNotFound()
+ r = CommonMiddleware(get_response_404).process_response(request, response)
+ self.assertEqual(r.status_code, 301)
+ self.assertEqual(r.url, "/%2Fevil.com/security/")
+ r = CommonMiddleware(get_response_404)(request)
+ self.assertEqual(r.status_code, 301)
+ self.assertEqual(r.url, "/%2Fevil.com/security/")
+
+ @override_settings(APPEND_SLASH=False, PREPEND_WWW=True)
+ def test_prepend_www(self):
+ request = self.rf.get("/path/")
+ r = CommonMiddleware(get_response_empty).process_request(request)
+ self.assertEqual(r.status_code, 301)
+ self.assertEqual(r.url, "http://www.testserver/path/")
+
+ @override_settings(APPEND_SLASH=True, PREPEND_WWW=True)
+ def test_prepend_www_append_slash_have_slash(self):
+ request = self.rf.get("/slash/")
+ r = CommonMiddleware(get_response_empty).process_request(request)
+ self.assertEqual(r.status_code, 301)
+ self.assertEqual(r.url, "http://www.testserver/slash/")
+
+ @override_settings(APPEND_SLASH=True, PREPEND_WWW=True)
+ def test_prepend_www_append_slash_slashless(self):
+ request = self.rf.get("/slash")
+ r = CommonMiddleware(get_response_empty).process_request(request)
+ self.assertEqual(r.status_code, 301)
+ self.assertEqual(r.url, "http://www.testserver/slash/")
+
+ # The following tests examine expected behavior given a custom URLconf that
+ # overrides the default one through the request object.
+
+ @override_settings(APPEND_SLASH=True)
+ def test_append_slash_have_slash_custom_urlconf(self):
+ """
+ URLs with slashes should go unmolested.
+ """
+ request = self.rf.get("/customurlconf/slash/")
+ request.urlconf = "middleware.extra_urls"
+ self.assertIsNone(CommonMiddleware(get_response_404).process_request(request))
+ self.assertEqual(CommonMiddleware(get_response_404)(request).status_code, 404)
+
+ @override_settings(APPEND_SLASH=True)
+ def test_append_slash_slashless_resource_custom_urlconf(self):
+ """
+ Matches to explicit slashless URLs should go unmolested.
+ """
+
+ def get_response(req):
+ return HttpResponse("web content")
+
+ request = self.rf.get("/customurlconf/noslash")
+ request.urlconf = "middleware.extra_urls"
+ self.assertIsNone(CommonMiddleware(get_response).process_request(request))
+ self.assertEqual(
+ CommonMiddleware(get_response)(request).content, b"web content"
+ )
+
+ @override_settings(APPEND_SLASH=True)
+ def test_append_slash_slashless_unknown_custom_urlconf(self):
+ """
+ APPEND_SLASH should not redirect to unknown resources.
+ """
+ request = self.rf.get("/customurlconf/unknown")
+ request.urlconf = "middleware.extra_urls"
+ self.assertIsNone(CommonMiddleware(get_response_404).process_request(request))
+ self.assertEqual(CommonMiddleware(get_response_404)(request).status_code, 404)
+
+ @override_settings(APPEND_SLASH=True)
+ def test_append_slash_redirect_custom_urlconf(self):
+ """
+ APPEND_SLASH should redirect slashless URLs to a valid pattern.
+ """
+ request = self.rf.get("/customurlconf/slash")
+ request.urlconf = "middleware.extra_urls"
+ r = CommonMiddleware(get_response_404)(request)
+ self.assertIsNotNone(
+ r,
+ "CommonMiddleware failed to return APPEND_SLASH redirect using "
+ "request.urlconf",
+ )
+ self.assertEqual(r.status_code, 301)
+ self.assertEqual(r.url, "/customurlconf/slash/")
+
+ @override_settings(APPEND_SLASH=True, DEBUG=True)
+ def test_append_slash_no_redirect_on_POST_in_DEBUG_custom_urlconf(self):
+ """
+ While in debug mode, an exception is raised with a warning
+ when a failed attempt is made to POST to an URL which would normally be
+ redirected to a slashed version.
+ """
+ request = self.rf.get("/customurlconf/slash")
+ request.urlconf = "middleware.extra_urls"
+ request.method = "POST"
+ with self.assertRaisesMessage(RuntimeError, "end in a slash"):
+ CommonMiddleware(get_response_404)(request)
+
+ @override_settings(APPEND_SLASH=False)
+ def test_append_slash_disabled_custom_urlconf(self):
+ """
+ Disabling append slash functionality should leave slashless URLs alone.
+ """
+ request = self.rf.get("/customurlconf/slash")
+ request.urlconf = "middleware.extra_urls"
+ self.assertIsNone(CommonMiddleware(get_response_404).process_request(request))
+ self.assertEqual(CommonMiddleware(get_response_404)(request).status_code, 404)
+
+ @override_settings(APPEND_SLASH=True)
+ def test_append_slash_quoted_custom_urlconf(self):
+ """
+ URLs which require quoting should be redirected to their slash version.
+ """
+ request = self.rf.get(quote("/customurlconf/needsquoting#"))
+ request.urlconf = "middleware.extra_urls"
+ r = CommonMiddleware(get_response_404)(request)
+ self.assertIsNotNone(
+ r,
+ "CommonMiddleware failed to return APPEND_SLASH redirect using "
+ "request.urlconf",
+ )
+ self.assertEqual(r.status_code, 301)
+ self.assertEqual(r.url, "/customurlconf/needsquoting%23/")
+
+ @override_settings(APPEND_SLASH=False, PREPEND_WWW=True)
+ def test_prepend_www_custom_urlconf(self):
+ request = self.rf.get("/customurlconf/path/")
+ request.urlconf = "middleware.extra_urls"
+ r = CommonMiddleware(get_response_empty).process_request(request)
+ self.assertEqual(r.status_code, 301)
+ self.assertEqual(r.url, "http://www.testserver/customurlconf/path/")
+
+ @override_settings(APPEND_SLASH=True, PREPEND_WWW=True)
+ def test_prepend_www_append_slash_have_slash_custom_urlconf(self):
+ request = self.rf.get("/customurlconf/slash/")
+ request.urlconf = "middleware.extra_urls"
+ r = CommonMiddleware(get_response_empty).process_request(request)
+ self.assertEqual(r.status_code, 301)
+ self.assertEqual(r.url, "http://www.testserver/customurlconf/slash/")
+
+ @override_settings(APPEND_SLASH=True, PREPEND_WWW=True)
+ def test_prepend_www_append_slash_slashless_custom_urlconf(self):
+ request = self.rf.get("/customurlconf/slash")
+ request.urlconf = "middleware.extra_urls"
+ r = CommonMiddleware(get_response_empty).process_request(request)
+ self.assertEqual(r.status_code, 301)
+ self.assertEqual(r.url, "http://www.testserver/customurlconf/slash/")
+
+ # Tests for the Content-Length header
+
+ def test_content_length_header_added(self):
+ def get_response(req):
+ response = HttpResponse("content")
+ self.assertNotIn("Content-Length", response)
+ return response
+
+ response = CommonMiddleware(get_response)(self.rf.get("/"))
+ self.assertEqual(int(response.headers["Content-Length"]), len(response.content))
+
+ def test_content_length_header_not_added_for_streaming_response(self):
+ def get_response(req):
+ response = StreamingHttpResponse("content")
+ self.assertNotIn("Content-Length", response)
+ return response
+
+ response = CommonMiddleware(get_response)(self.rf.get("/"))
+ self.assertNotIn("Content-Length", response)
+
+ def test_content_length_header_not_changed(self):
+ bad_content_length = 500
+
+ def get_response(req):
+ response = HttpResponse()
+ response.headers["Content-Length"] = bad_content_length
+ return response
+
+ response = CommonMiddleware(get_response)(self.rf.get("/"))
+ self.assertEqual(int(response.headers["Content-Length"]), bad_content_length)
+
+ # Other tests
+
+ @override_settings(DISALLOWED_USER_AGENTS=[re.compile(r"foo")])
+ def test_disallowed_user_agents(self):
+ request = self.rf.get("/slash")
+ request.META["HTTP_USER_AGENT"] = "foo"
+ with self.assertRaisesMessage(PermissionDenied, "Forbidden user agent"):
+ CommonMiddleware(get_response_empty).process_request(request)
+
+ def test_non_ascii_query_string_does_not_crash(self):
+ """Regression test for #15152"""
+ request = self.rf.get("/slash")
+ request.META["QUERY_STRING"] = "drink=café"
+ r = CommonMiddleware(get_response_empty).process_request(request)
+ self.assertIsNone(r)
+ response = HttpResponseNotFound()
+ r = CommonMiddleware(get_response_empty).process_response(request, response)
+ self.assertEqual(r.status_code, 301)
+
+ def test_response_redirect_class(self):
+ request = self.rf.get("/slash")
+ r = CommonMiddleware(get_response_404)(request)
+ self.assertEqual(r.status_code, 301)
+ self.assertEqual(r.url, "/slash/")
+ self.assertIsInstance(r, HttpResponsePermanentRedirect)
+
+ def test_response_redirect_class_subclass(self):
+ class MyCommonMiddleware(CommonMiddleware):
+ response_redirect_class = HttpResponseRedirect
+
+ request = self.rf.get("/slash")
+ r = MyCommonMiddleware(get_response_404)(request)
+ self.assertEqual(r.status_code, 302)
+ self.assertEqual(r.url, "/slash/")
+ self.assertIsInstance(r, HttpResponseRedirect)
+
+
+@override_settings(
+ IGNORABLE_404_URLS=[re.compile(r"foo")],
+ MANAGERS=[("PHD", "PHB@dilbert.com")],
+)
+class BrokenLinkEmailsMiddlewareTest(SimpleTestCase):
+ rf = RequestFactory()
+
+ def setUp(self):
+ self.req = self.rf.get("/regular_url/that/does/not/exist")
+
+ def get_response(self, req):
+ return self.client.get(req.path)
+
+ def test_404_error_reporting(self):
+ self.req.META["HTTP_REFERER"] = "/another/url/"
+ BrokenLinkEmailsMiddleware(self.get_response)(self.req)
+ self.assertEqual(len(mail.outbox), 1)
+ self.assertIn("Broken", mail.outbox[0].subject)
+
+ def test_404_error_reporting_no_referer(self):
+ BrokenLinkEmailsMiddleware(self.get_response)(self.req)
+ self.assertEqual(len(mail.outbox), 0)
+
+ def test_404_error_reporting_ignored_url(self):
+ self.req.path = self.req.path_info = "foo_url/that/does/not/exist"
+ BrokenLinkEmailsMiddleware(self.get_response)(self.req)
+ self.assertEqual(len(mail.outbox), 0)
+
+ def test_custom_request_checker(self):
+ class SubclassedMiddleware(BrokenLinkEmailsMiddleware):
+ ignored_user_agent_patterns = (
+ re.compile(r"Spider.*"),
+ re.compile(r"Robot.*"),
+ )
+
+ def is_ignorable_request(self, request, uri, domain, referer):
+ """Check user-agent in addition to normal checks."""
+ if super().is_ignorable_request(request, uri, domain, referer):
+ return True
+ user_agent = request.META["HTTP_USER_AGENT"]
+ return any(
+ pattern.search(user_agent)
+ for pattern in self.ignored_user_agent_patterns
+ )
+
+ self.req.META["HTTP_REFERER"] = "/another/url/"
+ self.req.META["HTTP_USER_AGENT"] = "Spider machine 3.4"
+ SubclassedMiddleware(self.get_response)(self.req)
+ self.assertEqual(len(mail.outbox), 0)
+ self.req.META["HTTP_USER_AGENT"] = "My user agent"
+ SubclassedMiddleware(self.get_response)(self.req)
+ self.assertEqual(len(mail.outbox), 1)
+
+ def test_referer_equal_to_requested_url(self):
+ """
+ Some bots set the referer to the current URL to avoid being blocked by
+ an referer check (#25302).
+ """
+ self.req.META["HTTP_REFERER"] = self.req.path
+ BrokenLinkEmailsMiddleware(self.get_response)(self.req)
+ self.assertEqual(len(mail.outbox), 0)
+
+ # URL with scheme and domain should also be ignored
+ self.req.META["HTTP_REFERER"] = "http://testserver%s" % self.req.path
+ BrokenLinkEmailsMiddleware(self.get_response)(self.req)
+ self.assertEqual(len(mail.outbox), 0)
+
+ # URL with a different scheme should be ignored as well because bots
+ # tend to use http:// in referers even when browsing HTTPS websites.
+ self.req.META["HTTP_X_PROTO"] = "https"
+ self.req.META["SERVER_PORT"] = 443
+ with self.settings(SECURE_PROXY_SSL_HEADER=("HTTP_X_PROTO", "https")):
+ BrokenLinkEmailsMiddleware(self.get_response)(self.req)
+ self.assertEqual(len(mail.outbox), 0)
+
+ def test_referer_equal_to_requested_url_on_another_domain(self):
+ self.req.META["HTTP_REFERER"] = "http://anotherserver%s" % self.req.path
+ BrokenLinkEmailsMiddleware(self.get_response)(self.req)
+ self.assertEqual(len(mail.outbox), 1)
+
+ @override_settings(APPEND_SLASH=True)
+ def test_referer_equal_to_requested_url_without_trailing_slash_with_append_slash(
+ self,
+ ):
+ self.req.path = self.req.path_info = "/regular_url/that/does/not/exist/"
+ self.req.META["HTTP_REFERER"] = self.req.path_info[:-1]
+ BrokenLinkEmailsMiddleware(self.get_response)(self.req)
+ self.assertEqual(len(mail.outbox), 0)
+
+ @override_settings(APPEND_SLASH=False)
+ def test_referer_equal_to_requested_url_without_trailing_slash_with_no_append_slash(
+ self,
+ ):
+ self.req.path = self.req.path_info = "/regular_url/that/does/not/exist/"
+ self.req.META["HTTP_REFERER"] = self.req.path_info[:-1]
+ BrokenLinkEmailsMiddleware(self.get_response)(self.req)
+ self.assertEqual(len(mail.outbox), 1)
+
+
+@override_settings(ROOT_URLCONF="middleware.cond_get_urls")
+class ConditionalGetMiddlewareTest(SimpleTestCase):
+ request_factory = RequestFactory()
+
+ def setUp(self):
+ self.req = self.request_factory.get("/")
+ self.resp_headers = {}
+
+ def get_response(self, req):
+ resp = self.client.get(req.path_info)
+ for key, value in self.resp_headers.items():
+ resp[key] = value
+ return resp
+
+ # Tests for the ETag header
+
+ def test_middleware_calculates_etag(self):
+ resp = ConditionalGetMiddleware(self.get_response)(self.req)
+ self.assertEqual(resp.status_code, 200)
+ self.assertNotEqual("", resp["ETag"])
+
+ def test_middleware_wont_overwrite_etag(self):
+ self.resp_headers["ETag"] = "eggs"
+ resp = ConditionalGetMiddleware(self.get_response)(self.req)
+ self.assertEqual(resp.status_code, 200)
+ self.assertEqual("eggs", resp["ETag"])
+
+ def test_no_etag_streaming_response(self):
+ def get_response(req):
+ return StreamingHttpResponse(["content"])
+
+ self.assertFalse(
+ ConditionalGetMiddleware(get_response)(self.req).has_header("ETag")
+ )
+
+ def test_no_etag_response_empty_content(self):
+ def get_response(req):
+ return HttpResponse()
+
+ self.assertFalse(
+ ConditionalGetMiddleware(get_response)(self.req).has_header("ETag")
+ )
+
+ def test_no_etag_no_store_cache(self):
+ self.resp_headers["Cache-Control"] = "No-Cache, No-Store, Max-age=0"
+ self.assertFalse(
+ ConditionalGetMiddleware(self.get_response)(self.req).has_header("ETag")
+ )
+
+ def test_etag_extended_cache_control(self):
+ self.resp_headers["Cache-Control"] = 'my-directive="my-no-store"'
+ self.assertTrue(
+ ConditionalGetMiddleware(self.get_response)(self.req).has_header("ETag")
+ )
+
+ def test_if_none_match_and_no_etag(self):
+ self.req.META["HTTP_IF_NONE_MATCH"] = "spam"
+ resp = ConditionalGetMiddleware(self.get_response)(self.req)
+ self.assertEqual(resp.status_code, 200)
+
+ def test_no_if_none_match_and_etag(self):
+ self.resp_headers["ETag"] = "eggs"
+ resp = ConditionalGetMiddleware(self.get_response)(self.req)
+ self.assertEqual(resp.status_code, 200)
+
+ def test_if_none_match_and_same_etag(self):
+ self.req.META["HTTP_IF_NONE_MATCH"] = '"spam"'
+ self.resp_headers["ETag"] = '"spam"'
+ resp = ConditionalGetMiddleware(self.get_response)(self.req)
+ self.assertEqual(resp.status_code, 304)
+
+ def test_if_none_match_and_different_etag(self):
+ self.req.META["HTTP_IF_NONE_MATCH"] = "spam"
+ self.resp_headers["ETag"] = "eggs"
+ resp = ConditionalGetMiddleware(self.get_response)(self.req)
+ self.assertEqual(resp.status_code, 200)
+
+ def test_if_none_match_and_redirect(self):
+ def get_response(req):
+ resp = self.client.get(req.path_info)
+ resp["ETag"] = "spam"
+ resp["Location"] = "/"
+ resp.status_code = 301
+ return resp
+
+ self.req.META["HTTP_IF_NONE_MATCH"] = "spam"
+ resp = ConditionalGetMiddleware(get_response)(self.req)
+ self.assertEqual(resp.status_code, 301)
+
+ def test_if_none_match_and_client_error(self):
+ def get_response(req):
+ resp = self.client.get(req.path_info)
+ resp["ETag"] = "spam"
+ resp.status_code = 400
+ return resp
+
+ self.req.META["HTTP_IF_NONE_MATCH"] = "spam"
+ resp = ConditionalGetMiddleware(get_response)(self.req)
+ self.assertEqual(resp.status_code, 400)
+
+ # Tests for the Last-Modified header
+
+ def test_if_modified_since_and_no_last_modified(self):
+ self.req.META["HTTP_IF_MODIFIED_SINCE"] = "Sat, 12 Feb 2011 17:38:44 GMT"
+ resp = ConditionalGetMiddleware(self.get_response)(self.req)
+ self.assertEqual(resp.status_code, 200)
+
+ def test_no_if_modified_since_and_last_modified(self):
+ self.resp_headers["Last-Modified"] = "Sat, 12 Feb 2011 17:38:44 GMT"
+ resp = ConditionalGetMiddleware(self.get_response)(self.req)
+ self.assertEqual(resp.status_code, 200)
+
+ def test_if_modified_since_and_same_last_modified(self):
+ self.req.META["HTTP_IF_MODIFIED_SINCE"] = "Sat, 12 Feb 2011 17:38:44 GMT"
+ self.resp_headers["Last-Modified"] = "Sat, 12 Feb 2011 17:38:44 GMT"
+ self.resp = ConditionalGetMiddleware(self.get_response)(self.req)
+ self.assertEqual(self.resp.status_code, 304)
+
+ def test_if_modified_since_and_last_modified_in_the_past(self):
+ self.req.META["HTTP_IF_MODIFIED_SINCE"] = "Sat, 12 Feb 2011 17:38:44 GMT"
+ self.resp_headers["Last-Modified"] = "Sat, 12 Feb 2011 17:35:44 GMT"
+ resp = ConditionalGetMiddleware(self.get_response)(self.req)
+ self.assertEqual(resp.status_code, 304)
+
+ def test_if_modified_since_and_last_modified_in_the_future(self):
+ self.req.META["HTTP_IF_MODIFIED_SINCE"] = "Sat, 12 Feb 2011 17:38:44 GMT"
+ self.resp_headers["Last-Modified"] = "Sat, 12 Feb 2011 17:41:44 GMT"
+ self.resp = ConditionalGetMiddleware(self.get_response)(self.req)
+ self.assertEqual(self.resp.status_code, 200)
+
+ def test_if_modified_since_and_redirect(self):
+ def get_response(req):
+ resp = self.client.get(req.path_info)
+ resp["Last-Modified"] = "Sat, 12 Feb 2011 17:35:44 GMT"
+ resp["Location"] = "/"
+ resp.status_code = 301
+ return resp
+
+ self.req.META["HTTP_IF_MODIFIED_SINCE"] = "Sat, 12 Feb 2011 17:38:44 GMT"
+ resp = ConditionalGetMiddleware(get_response)(self.req)
+ self.assertEqual(resp.status_code, 301)
+
+ def test_if_modified_since_and_client_error(self):
+ def get_response(req):
+ resp = self.client.get(req.path_info)
+ resp["Last-Modified"] = "Sat, 12 Feb 2011 17:35:44 GMT"
+ resp.status_code = 400
+ return resp
+
+ self.req.META["HTTP_IF_MODIFIED_SINCE"] = "Sat, 12 Feb 2011 17:38:44 GMT"
+ resp = ConditionalGetMiddleware(get_response)(self.req)
+ self.assertEqual(resp.status_code, 400)
+
+ def test_not_modified_headers(self):
+ """
+ The 304 Not Modified response should include only the headers required
+ by RFC 9110 Section 15.4.5, Last-Modified, and the cookies.
+ """
+
+ def get_response(req):
+ resp = self.client.get(req.path_info)
+ resp["Date"] = "Sat, 12 Feb 2011 17:35:44 GMT"
+ resp["Last-Modified"] = "Sat, 12 Feb 2011 17:35:44 GMT"
+ resp["Expires"] = "Sun, 13 Feb 2011 17:35:44 GMT"
+ resp["Vary"] = "Cookie"
+ resp["Cache-Control"] = "public"
+ resp["Content-Location"] = "/alt"
+ resp["Content-Language"] = "en" # shouldn't be preserved
+ resp["ETag"] = '"spam"'
+ resp.set_cookie("key", "value")
+ return resp
+
+ self.req.META["HTTP_IF_NONE_MATCH"] = '"spam"'
+
+ new_response = ConditionalGetMiddleware(get_response)(self.req)
+ self.assertEqual(new_response.status_code, 304)
+ base_response = get_response(self.req)
+ for header in (
+ "Cache-Control",
+ "Content-Location",
+ "Date",
+ "ETag",
+ "Expires",
+ "Last-Modified",
+ "Vary",
+ ):
+ self.assertEqual(
+ new_response.headers[header], base_response.headers[header]
+ )
+ self.assertEqual(new_response.cookies, base_response.cookies)
+ self.assertNotIn("Content-Language", new_response)
+
+ def test_no_unsafe(self):
+ """
+ ConditionalGetMiddleware shouldn't return a conditional response on an
+ unsafe request. A response has already been generated by the time
+ ConditionalGetMiddleware is called, so it's too late to return a 412
+ Precondition Failed.
+ """
+
+ def get_200_response(req):
+ return HttpResponse(status=200)
+
+ response = ConditionalGetMiddleware(self.get_response)(self.req)
+ etag = response.headers["ETag"]
+ put_request = self.request_factory.put("/", headers={"if-match": etag})
+ conditional_get_response = ConditionalGetMiddleware(get_200_response)(
+ put_request
+ )
+ self.assertEqual(
+ conditional_get_response.status_code, 200
+ ) # should never be a 412
+
+ def test_no_head(self):
+ """
+ ConditionalGetMiddleware shouldn't compute and return an ETag on a
+ HEAD request since it can't do so accurately without access to the
+ response body of the corresponding GET.
+ """
+
+ def get_200_response(req):
+ return HttpResponse(status=200)
+
+ request = self.request_factory.head("/")
+ conditional_get_response = ConditionalGetMiddleware(get_200_response)(request)
+ self.assertNotIn("ETag", conditional_get_response)
+
+
+class XFrameOptionsMiddlewareTest(SimpleTestCase):
+ """
+ Tests for the X-Frame-Options clickjacking prevention middleware.
+ """
+
+ def test_same_origin(self):
+ """
+ The X_FRAME_OPTIONS setting can be set to SAMEORIGIN to have the
+ middleware use that value for the HTTP header.
+ """
+ with override_settings(X_FRAME_OPTIONS="SAMEORIGIN"):
+ r = XFrameOptionsMiddleware(get_response_empty)(HttpRequest())
+ self.assertEqual(r.headers["X-Frame-Options"], "SAMEORIGIN")
+
+ with override_settings(X_FRAME_OPTIONS="sameorigin"):
+ r = XFrameOptionsMiddleware(get_response_empty)(HttpRequest())
+ self.assertEqual(r.headers["X-Frame-Options"], "SAMEORIGIN")
+
+ def test_deny(self):
+ """
+ The X_FRAME_OPTIONS setting can be set to DENY to have the middleware
+ use that value for the HTTP header.
+ """
+ with override_settings(X_FRAME_OPTIONS="DENY"):
+ r = XFrameOptionsMiddleware(get_response_empty)(HttpRequest())
+ self.assertEqual(r.headers["X-Frame-Options"], "DENY")
+
+ with override_settings(X_FRAME_OPTIONS="deny"):
+ r = XFrameOptionsMiddleware(get_response_empty)(HttpRequest())
+ self.assertEqual(r.headers["X-Frame-Options"], "DENY")
+
+ def test_defaults_sameorigin(self):
+ """
+ If the X_FRAME_OPTIONS setting is not set then it defaults to
+ DENY.
+ """
+ with override_settings(X_FRAME_OPTIONS=None):
+ del settings.X_FRAME_OPTIONS # restored by override_settings
+ r = XFrameOptionsMiddleware(get_response_empty)(HttpRequest())
+ self.assertEqual(r.headers["X-Frame-Options"], "DENY")
+
+ def test_dont_set_if_set(self):
+ """
+ If the X-Frame-Options header is already set then the middleware does
+ not attempt to override it.
+ """
+
+ def same_origin_response(request):
+ response = HttpResponse()
+ response.headers["X-Frame-Options"] = "SAMEORIGIN"
+ return response
+
+ def deny_response(request):
+ response = HttpResponse()
+ response.headers["X-Frame-Options"] = "DENY"
+ return response
+
+ with override_settings(X_FRAME_OPTIONS="DENY"):
+ r = XFrameOptionsMiddleware(same_origin_response)(HttpRequest())
+ self.assertEqual(r.headers["X-Frame-Options"], "SAMEORIGIN")
+
+ with override_settings(X_FRAME_OPTIONS="SAMEORIGIN"):
+ r = XFrameOptionsMiddleware(deny_response)(HttpRequest())
+ self.assertEqual(r.headers["X-Frame-Options"], "DENY")
+
+ def test_response_exempt(self):
+ """
+ If the response has an xframe_options_exempt attribute set to False
+ then it still sets the header, but if it's set to True then it doesn't.
+ """
+
+ def xframe_exempt_response(request):
+ response = HttpResponse()
+ response.xframe_options_exempt = True
+ return response
+
+ def xframe_not_exempt_response(request):
+ response = HttpResponse()
+ response.xframe_options_exempt = False
+ return response
+
+ with override_settings(X_FRAME_OPTIONS="SAMEORIGIN"):
+ r = XFrameOptionsMiddleware(xframe_not_exempt_response)(HttpRequest())
+ self.assertEqual(r.headers["X-Frame-Options"], "SAMEORIGIN")
+
+ r = XFrameOptionsMiddleware(xframe_exempt_response)(HttpRequest())
+ self.assertIsNone(r.headers.get("X-Frame-Options"))
+
+ def test_is_extendable(self):
+ """
+ The XFrameOptionsMiddleware method that determines the X-Frame-Options
+ header value can be overridden based on something in the request or
+ response.
+ """
+
+ class OtherXFrameOptionsMiddleware(XFrameOptionsMiddleware):
+ # This is just an example for testing purposes...
+ def get_xframe_options_value(self, request, response):
+ if getattr(request, "sameorigin", False):
+ return "SAMEORIGIN"
+ if getattr(response, "sameorigin", False):
+ return "SAMEORIGIN"
+ return "DENY"
+
+ def same_origin_response(request):
+ response = HttpResponse()
+ response.sameorigin = True
+ return response
+
+ with override_settings(X_FRAME_OPTIONS="DENY"):
+ r = OtherXFrameOptionsMiddleware(same_origin_response)(HttpRequest())
+ self.assertEqual(r.headers["X-Frame-Options"], "SAMEORIGIN")
+
+ request = HttpRequest()
+ request.sameorigin = True
+ r = OtherXFrameOptionsMiddleware(get_response_empty)(request)
+ self.assertEqual(r.headers["X-Frame-Options"], "SAMEORIGIN")
+
+ with override_settings(X_FRAME_OPTIONS="SAMEORIGIN"):
+ r = OtherXFrameOptionsMiddleware(get_response_empty)(HttpRequest())
+ self.assertEqual(r.headers["X-Frame-Options"], "DENY")
+
+
+class GZipMiddlewareTest(SimpleTestCase):
+ """
+ Tests the GZipMiddleware.
+ """
+
+ short_string = b"This string is too short to be worth compressing."
+ compressible_string = b"a" * 500
+ incompressible_string = b"".join(
+ int2byte(random.randint(0, 255)) for _ in range(500)
+ )
+ sequence = [b"a" * 500, b"b" * 200, b"a" * 300]
+ sequence_unicode = ["a" * 500, "é" * 200, "a" * 300]
+ request_factory = RequestFactory()
+
+ def setUp(self):
+ self.req = self.request_factory.get("/")
+ self.req.META["HTTP_ACCEPT_ENCODING"] = "gzip, deflate"
+ self.req.META[
+ "HTTP_USER_AGENT"
+ ] = "Mozilla/5.0 (Windows NT 5.1; rv:9.0.1) Gecko/20100101 Firefox/9.0.1"
+ self.resp = HttpResponse()
+ self.resp.status_code = 200
+ self.resp.content = self.compressible_string
+ self.resp["Content-Type"] = "text/html; charset=UTF-8"
+
+ def get_response(self, request):
+ return self.resp
+
+ @staticmethod
+ def decompress(gzipped_string):
+ with gzip.GzipFile(mode="rb", fileobj=BytesIO(gzipped_string)) as f:
+ return f.read()
+
+ @staticmethod
+ def get_mtime(gzipped_string):
+ with gzip.GzipFile(mode="rb", fileobj=BytesIO(gzipped_string)) as f:
+ f.read() # must read the data before accessing the header
+ return f.mtime
+
+ def test_compress_response(self):
+ """
+ Compression is performed on responses with compressible content.
+ """
+ r = GZipMiddleware(self.get_response)(self.req)
+ self.assertEqual(self.decompress(r.content), self.compressible_string)
+ self.assertEqual(r.get("Content-Encoding"), "gzip")
+ self.assertEqual(r.get("Content-Length"), str(len(r.content)))
+
+ def test_compress_streaming_response(self):
+ """
+ Compression is performed on responses with streaming content.
+ """
+
+ def get_stream_response(request):
+ resp = StreamingHttpResponse(self.sequence)
+ resp["Content-Type"] = "text/html; charset=UTF-8"
+ return resp
+
+ r = GZipMiddleware(get_stream_response)(self.req)
+ self.assertEqual(self.decompress(b"".join(r)), b"".join(self.sequence))
+ self.assertEqual(r.get("Content-Encoding"), "gzip")
+ self.assertFalse(r.has_header("Content-Length"))
+
+ async def test_compress_async_streaming_response(self):
+ """
+ Compression is performed on responses with async streaming content.
+ """
+
+ async def get_stream_response(request):
+ async def iterator():
+ for chunk in self.sequence:
+ yield chunk
+
+ resp = StreamingHttpResponse(iterator())
+ resp["Content-Type"] = "text/html; charset=UTF-8"
+ return resp
+
+ r = await GZipMiddleware(get_stream_response)(self.req)
+ self.assertEqual(
+ self.decompress(b"".join([chunk async for chunk in r])),
+ b"".join(self.sequence),
+ )
+ self.assertEqual(r.get("Content-Encoding"), "gzip")
+ self.assertFalse(r.has_header("Content-Length"))
+
+ def test_compress_streaming_response_unicode(self):
+ """
+ Compression is performed on responses with streaming Unicode content.
+ """
+
+ def get_stream_response_unicode(request):
+ resp = StreamingHttpResponse(self.sequence_unicode)
+ resp["Content-Type"] = "text/html; charset=UTF-8"
+ return resp
+
+ r = GZipMiddleware(get_stream_response_unicode)(self.req)
+ self.assertEqual(
+ self.decompress(b"".join(r)),
+ b"".join(x.encode() for x in self.sequence_unicode),
+ )
+ self.assertEqual(r.get("Content-Encoding"), "gzip")
+ self.assertFalse(r.has_header("Content-Length"))
+
+ def test_compress_file_response(self):
+ """
+ Compression is performed on FileResponse.
+ """
+ with open(__file__, "rb") as file1:
+
+ def get_response(req):
+ file_resp = FileResponse(file1)
+ file_resp["Content-Type"] = "text/html; charset=UTF-8"
+ return file_resp
+
+ r = GZipMiddleware(get_response)(self.req)
+ with open(__file__, "rb") as file2:
+ self.assertEqual(self.decompress(b"".join(r)), file2.read())
+ self.assertEqual(r.get("Content-Encoding"), "gzip")
+ self.assertIsNot(r.file_to_stream, file1)
+
+ def test_compress_non_200_response(self):
+ """
+ Compression is performed on responses with a status other than 200
+ (#10762).
+ """
+ self.resp.status_code = 404
+ r = GZipMiddleware(self.get_response)(self.req)
+ self.assertEqual(self.decompress(r.content), self.compressible_string)
+ self.assertEqual(r.get("Content-Encoding"), "gzip")
+
+ def test_no_compress_short_response(self):
+ """
+ Compression isn't performed on responses with short content.
+ """
+ self.resp.content = self.short_string
+ r = GZipMiddleware(self.get_response)(self.req)
+ self.assertEqual(r.content, self.short_string)
+ self.assertIsNone(r.get("Content-Encoding"))
+
+ def test_no_compress_compressed_response(self):
+ """
+ Compression isn't performed on responses that are already compressed.
+ """
+ self.resp["Content-Encoding"] = "deflate"
+ r = GZipMiddleware(self.get_response)(self.req)
+ self.assertEqual(r.content, self.compressible_string)
+ self.assertEqual(r.get("Content-Encoding"), "deflate")
+
+ def test_no_compress_incompressible_response(self):
+ """
+ Compression isn't performed on responses with incompressible content.
+ """
+ self.resp.content = self.incompressible_string
+ r = GZipMiddleware(self.get_response)(self.req)
+ self.assertEqual(r.content, self.incompressible_string)
+ self.assertIsNone(r.get("Content-Encoding"))
+
+ def test_compress_deterministic(self):
+ """
+ Compression results are the same for the same content and don't
+ include a modification time (since that would make the results
+ of compression non-deterministic and prevent
+ ConditionalGetMiddleware from recognizing conditional matches
+ on gzipped content).
+ """
+
+ class DeterministicGZipMiddleware(GZipMiddleware):
+ max_random_bytes = 0
+
+ r1 = DeterministicGZipMiddleware(self.get_response)(self.req)
+ r2 = DeterministicGZipMiddleware(self.get_response)(self.req)
+ self.assertEqual(r1.content, r2.content)
+ self.assertEqual(self.get_mtime(r1.content), 0)
+ self.assertEqual(self.get_mtime(r2.content), 0)
+
+ def test_random_bytes(self):
+ """A random number of bytes is added to mitigate the BREACH attack."""
+ with mock.patch(
+ "django.utils.text.secrets.randbelow", autospec=True, return_value=3
+ ):
+ r = GZipMiddleware(self.get_response)(self.req)
+ # The fourth byte of a gzip stream contains flags.
+ self.assertEqual(r.content[3], gzip.FNAME)
+ # A 3 byte filename "aaa" and a null byte are added.
+ self.assertEqual(r.content[10:14], b"aaa\x00")
+ self.assertEqual(self.decompress(r.content), self.compressible_string)
+
+ def test_random_bytes_streaming_response(self):
+ """A random number of bytes is added to mitigate the BREACH attack."""
+
+ def get_stream_response(request):
+ resp = StreamingHttpResponse(self.sequence)
+ resp["Content-Type"] = "text/html; charset=UTF-8"
+ return resp
+
+ with mock.patch(
+ "django.utils.text.secrets.randbelow", autospec=True, return_value=3
+ ):
+ r = GZipMiddleware(get_stream_response)(self.req)
+ content = b"".join(r)
+ # The fourth byte of a gzip stream contains flags.
+ self.assertEqual(content[3], gzip.FNAME)
+ # A 3 byte filename "aaa" and a null byte are added.
+ self.assertEqual(content[10:14], b"aaa\x00")
+ self.assertEqual(self.decompress(content), b"".join(self.sequence))
+
+
+class ETagGZipMiddlewareTest(SimpleTestCase):
+ """
+ ETags are handled properly by GZipMiddleware.
+ """
+
+ rf = RequestFactory()
+ compressible_string = b"a" * 500
+
+ def test_strong_etag_modified(self):
+ """
+ GZipMiddleware makes a strong ETag weak.
+ """
+
+ def get_response(req):
+ response = HttpResponse(self.compressible_string)
+ response.headers["ETag"] = '"eggs"'
+ return response
+
+ request = self.rf.get("/", headers={"accept-encoding": "gzip, deflate"})
+ gzip_response = GZipMiddleware(get_response)(request)
+ self.assertEqual(gzip_response.headers["ETag"], 'W/"eggs"')
+
+ def test_weak_etag_not_modified(self):
+ """
+ GZipMiddleware doesn't modify a weak ETag.
+ """
+
+ def get_response(req):
+ response = HttpResponse(self.compressible_string)
+ response.headers["ETag"] = 'W/"eggs"'
+ return response
+
+ request = self.rf.get("/", headers={"accept-encoding": "gzip, deflate"})
+ gzip_response = GZipMiddleware(get_response)(request)
+ self.assertEqual(gzip_response.headers["ETag"], 'W/"eggs"')
+
+ def test_etag_match(self):
+ """
+ GZipMiddleware allows 304 Not Modified responses.
+ """
+
+ def get_response(req):
+ return HttpResponse(self.compressible_string)
+
+ def get_cond_response(req):
+ return ConditionalGetMiddleware(get_response)(req)
+
+ request = self.rf.get("/", headers={"accept-encoding": "gzip, deflate"})
+ response = GZipMiddleware(get_cond_response)(request)
+ gzip_etag = response.headers["ETag"]
+ next_request = self.rf.get(
+ "/",
+ headers={"accept-encoding": "gzip, deflate", "if-none-match": gzip_etag},
+ )
+ next_response = ConditionalGetMiddleware(get_response)(next_request)
+ self.assertEqual(next_response.status_code, 304)
diff --git a/testbed/django__django/tests/middleware/urls.py b/testbed/django__django/tests/middleware/urls.py
new file mode 100644
index 0000000000000000000000000000000000000000..294b80b192e5738b45edaf34c83d41906b36898e
--- /dev/null
+++ b/testbed/django__django/tests/middleware/urls.py
@@ -0,0 +1,14 @@
+from django.urls import path, re_path
+
+from . import views
+
+urlpatterns = [
+ path("noslash", views.empty_view),
+ path("slash/", views.empty_view),
+ path("needsquoting#/", views.empty_view),
+ # Accepts paths with two leading slashes.
+ re_path(r"^(.+)/security/$", views.empty_view),
+ # Should not append slash.
+ path("sensitive_fbv/", views.sensitive_fbv),
+ path("sensitive_cbv/", views.SensitiveCBV.as_view()),
+]
diff --git a/testbed/django__django/tests/middleware/views.py b/testbed/django__django/tests/middleware/views.py
new file mode 100644
index 0000000000000000000000000000000000000000..1de2edfd1b86732c8b0c82c5f3e222c95d6487ce
--- /dev/null
+++ b/testbed/django__django/tests/middleware/views.py
@@ -0,0 +1,19 @@
+from django.http import HttpResponse
+from django.utils.decorators import method_decorator
+from django.views.decorators.common import no_append_slash
+from django.views.generic import View
+
+
+def empty_view(request, *args, **kwargs):
+ return HttpResponse()
+
+
+@no_append_slash
+def sensitive_fbv(request, *args, **kwargs):
+ return HttpResponse()
+
+
+@method_decorator(no_append_slash, name="dispatch")
+class SensitiveCBV(View):
+ def get(self, *args, **kwargs):
+ return HttpResponse()
diff --git a/testbed/django__django/tests/middleware_exceptions/__init__.py b/testbed/django__django/tests/middleware_exceptions/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testbed/django__django/tests/middleware_exceptions/middleware.py b/testbed/django__django/tests/middleware_exceptions/middleware.py
new file mode 100644
index 0000000000000000000000000000000000000000..f50aa61327e69b1ecdf3d60ceb2227d0d286e58a
--- /dev/null
+++ b/testbed/django__django/tests/middleware_exceptions/middleware.py
@@ -0,0 +1,145 @@
+from asgiref.sync import iscoroutinefunction, markcoroutinefunction
+
+from django.http import Http404, HttpResponse
+from django.template import engines
+from django.template.response import TemplateResponse
+from django.utils.decorators import (
+ async_only_middleware,
+ sync_and_async_middleware,
+ sync_only_middleware,
+)
+
+log = []
+
+
+class BaseMiddleware:
+ def __init__(self, get_response):
+ self.get_response = get_response
+ if iscoroutinefunction(self.get_response):
+ markcoroutinefunction(self)
+
+ def __call__(self, request):
+ return self.get_response(request)
+
+
+class ProcessExceptionMiddleware(BaseMiddleware):
+ def process_exception(self, request, exception):
+ return HttpResponse("Exception caught")
+
+
+@async_only_middleware
+class AsyncProcessExceptionMiddleware(BaseMiddleware):
+ async def process_exception(self, request, exception):
+ return HttpResponse("Exception caught")
+
+
+class ProcessExceptionLogMiddleware(BaseMiddleware):
+ def process_exception(self, request, exception):
+ log.append("process-exception")
+
+
+class ProcessExceptionExcMiddleware(BaseMiddleware):
+ def process_exception(self, request, exception):
+ raise Exception("from process-exception")
+
+
+class ProcessViewMiddleware(BaseMiddleware):
+ def process_view(self, request, view_func, view_args, view_kwargs):
+ return HttpResponse("Processed view %s" % view_func.__name__)
+
+
+@async_only_middleware
+class AsyncProcessViewMiddleware(BaseMiddleware):
+ async def process_view(self, request, view_func, view_args, view_kwargs):
+ return HttpResponse("Processed view %s" % view_func.__name__)
+
+
+class ProcessViewNoneMiddleware(BaseMiddleware):
+ def process_view(self, request, view_func, view_args, view_kwargs):
+ log.append("processed view %s" % view_func.__name__)
+ return None
+
+
+class ProcessViewTemplateResponseMiddleware(BaseMiddleware):
+ def process_view(self, request, view_func, view_args, view_kwargs):
+ template = engines["django"].from_string(
+ "Processed view {{ view }}{% for m in mw %}\n{{ m }}{% endfor %}"
+ )
+ return TemplateResponse(
+ request,
+ template,
+ {"mw": [self.__class__.__name__], "view": view_func.__name__},
+ )
+
+
+class TemplateResponseMiddleware(BaseMiddleware):
+ def process_template_response(self, request, response):
+ response.context_data["mw"].append(self.__class__.__name__)
+ return response
+
+
+@async_only_middleware
+class AsyncTemplateResponseMiddleware(BaseMiddleware):
+ async def process_template_response(self, request, response):
+ response.context_data["mw"].append(self.__class__.__name__)
+ return response
+
+
+class LogMiddleware(BaseMiddleware):
+ def __call__(self, request):
+ response = self.get_response(request)
+ log.append((response.status_code, response.content))
+ return response
+
+
+class NoTemplateResponseMiddleware(BaseMiddleware):
+ def process_template_response(self, request, response):
+ return None
+
+
+@async_only_middleware
+class AsyncNoTemplateResponseMiddleware(BaseMiddleware):
+ async def process_template_response(self, request, response):
+ return None
+
+
+class NotFoundMiddleware(BaseMiddleware):
+ def __call__(self, request):
+ raise Http404("not found")
+
+
+class PaymentMiddleware(BaseMiddleware):
+ def __call__(self, request):
+ response = self.get_response(request)
+ response.status_code = 402
+ return response
+
+
+@async_only_middleware
+def async_payment_middleware(get_response):
+ async def middleware(request):
+ response = await get_response(request)
+ response.status_code = 402
+ return response
+
+ return middleware
+
+
+@sync_and_async_middleware
+class SyncAndAsyncMiddleware(BaseMiddleware):
+ pass
+
+
+@sync_only_middleware
+class DecoratedPaymentMiddleware(PaymentMiddleware):
+ pass
+
+
+class NotSyncOrAsyncMiddleware(BaseMiddleware):
+ """Middleware that is deliberately neither sync or async."""
+
+ sync_capable = False
+ async_capable = False
+
+ def __call__(self, request):
+ return self.get_response(request)
diff --git a/testbed/django__django/tests/middleware_exceptions/tests.py b/testbed/django__django/tests/middleware_exceptions/tests.py
new file mode 100644
index 0000000000000000000000000000000000000000..4f4ce5f2f86c243271b171400c57ddab6de1415a
--- /dev/null
+++ b/testbed/django__django/tests/middleware_exceptions/tests.py
@@ -0,0 +1,416 @@
+from django.conf import settings
+from django.core.exceptions import MiddlewareNotUsed
+from django.http import HttpResponse
+from django.test import RequestFactory, SimpleTestCase, override_settings
+
+from . import middleware as mw
+
+
+@override_settings(ROOT_URLCONF="middleware_exceptions.urls")
+class MiddlewareTests(SimpleTestCase):
+ def tearDown(self):
+ mw.log = []
+
+ @override_settings(
+ MIDDLEWARE=["middleware_exceptions.middleware.ProcessViewNoneMiddleware"]
+ )
+ def test_process_view_return_none(self):
+ response = self.client.get("/middleware_exceptions/view/")
+ self.assertEqual(mw.log, ["processed view normal_view"])
+ self.assertEqual(response.content, b"OK")
+
+ @override_settings(
+ MIDDLEWARE=["middleware_exceptions.middleware.ProcessViewMiddleware"]
+ )
+ def test_process_view_return_response(self):
+ response = self.client.get("/middleware_exceptions/view/")
+ self.assertEqual(response.content, b"Processed view normal_view")
+
+ @override_settings(
+ MIDDLEWARE=[
+ "middleware_exceptions.middleware.ProcessViewTemplateResponseMiddleware",
+ "middleware_exceptions.middleware.LogMiddleware",
+ ]
+ )
+ def test_templateresponse_from_process_view_rendered(self):
+ """
+ TemplateResponses returned from process_view() must be rendered before
+ being passed to any middleware that tries to access response.content,
+ such as middleware_exceptions.middleware.LogMiddleware.
+ """
+ response = self.client.get("/middleware_exceptions/view/")
+ self.assertEqual(
+ response.content,
+ b"Processed view normal_view\nProcessViewTemplateResponseMiddleware",
+ )
+
+ @override_settings(
+ MIDDLEWARE=[
+ "middleware_exceptions.middleware.ProcessViewTemplateResponseMiddleware",
+ "middleware_exceptions.middleware.TemplateResponseMiddleware",
+ ]
+ )
+ def test_templateresponse_from_process_view_passed_to_process_template_response(
+ self,
+ ):
+ """
+ TemplateResponses returned from process_view() should be passed to any
+ template response middleware.
+ """
+ response = self.client.get("/middleware_exceptions/view/")
+ expected_lines = [
+ b"Processed view normal_view",
+ b"ProcessViewTemplateResponseMiddleware",
+ b"TemplateResponseMiddleware",
+ ]
+ self.assertEqual(response.content, b"\n".join(expected_lines))
+
+ @override_settings(
+ MIDDLEWARE=["middleware_exceptions.middleware.TemplateResponseMiddleware"]
+ )
+ def test_process_template_response(self):
+ response = self.client.get("/middleware_exceptions/template_response/")
+ self.assertEqual(
+ response.content, b"template_response OK\nTemplateResponseMiddleware"
+ )
+
+ @override_settings(
+ MIDDLEWARE=["middleware_exceptions.middleware.NoTemplateResponseMiddleware"]
+ )
+ def test_process_template_response_returns_none(self):
+ msg = (
+ "NoTemplateResponseMiddleware.process_template_response didn't "
+ "return an HttpResponse object. It returned None instead."
+ )
+ with self.assertRaisesMessage(ValueError, msg):
+ self.client.get("/middleware_exceptions/template_response/")
+
+ @override_settings(MIDDLEWARE=["middleware_exceptions.middleware.LogMiddleware"])
+ def test_view_exception_converted_before_middleware(self):
+ response = self.client.get("/middleware_exceptions/permission_denied/")
+ self.assertEqual(mw.log, [(response.status_code, response.content)])
+ self.assertEqual(response.status_code, 403)
+
+ @override_settings(
+ MIDDLEWARE=["middleware_exceptions.middleware.ProcessExceptionMiddleware"]
+ )
+ def test_view_exception_handled_by_process_exception(self):
+ response = self.client.get("/middleware_exceptions/error/")
+ self.assertEqual(response.content, b"Exception caught")
+
+ @override_settings(
+ MIDDLEWARE=[
+ "middleware_exceptions.middleware.ProcessExceptionLogMiddleware",
+ "middleware_exceptions.middleware.ProcessExceptionMiddleware",
+ ]
+ )
+ def test_response_from_process_exception_short_circuits_remainder(self):
+ response = self.client.get("/middleware_exceptions/error/")
+ self.assertEqual(mw.log, [])
+ self.assertEqual(response.content, b"Exception caught")
+
+ @override_settings(
+ MIDDLEWARE=[
+ "middleware_exceptions.middleware.ProcessExceptionMiddleware",
+ "middleware_exceptions.middleware.ProcessExceptionLogMiddleware",
+ ]
+ )
+ def test_response_from_process_exception_when_return_response(self):
+ response = self.client.get("/middleware_exceptions/error/")
+ self.assertEqual(mw.log, ["process-exception"])
+ self.assertEqual(response.content, b"Exception caught")
+
+ @override_settings(
+ MIDDLEWARE=[
+ "middleware_exceptions.middleware.LogMiddleware",
+ "middleware_exceptions.middleware.NotFoundMiddleware",
+ ]
+ )
+ def test_exception_in_middleware_converted_before_prior_middleware(self):
+ response = self.client.get("/middleware_exceptions/view/")
+ self.assertEqual(mw.log, [(404, response.content)])
+ self.assertEqual(response.status_code, 404)
+
+ @override_settings(
+ MIDDLEWARE=["middleware_exceptions.middleware.ProcessExceptionMiddleware"]
+ )
+ def test_exception_in_render_passed_to_process_exception(self):
+ response = self.client.get("/middleware_exceptions/exception_in_render/")
+ self.assertEqual(response.content, b"Exception caught")
+
+
+@override_settings(ROOT_URLCONF="middleware_exceptions.urls")
+class RootUrlconfTests(SimpleTestCase):
+ @override_settings(ROOT_URLCONF=None)
+ def test_missing_root_urlconf(self):
+ # Removing ROOT_URLCONF is safe, as override_settings will restore
+ # the previously defined settings.
+ del settings.ROOT_URLCONF
+ with self.assertRaises(AttributeError):
+ self.client.get("/middleware_exceptions/view/")
+
+
+class MyMiddleware:
+ def __init__(self, get_response):
+ raise MiddlewareNotUsed
+
+ def process_request(self, request):
+ pass
+
+
+class MyMiddlewareWithExceptionMessage:
+ def __init__(self, get_response):
+ raise MiddlewareNotUsed("spam eggs")
+
+ def process_request(self, request):
+ pass
+
+
+@override_settings(
+ DEBUG=True,
+ ROOT_URLCONF="middleware_exceptions.urls",
+ MIDDLEWARE=["django.middleware.common.CommonMiddleware"],
+)
+class MiddlewareNotUsedTests(SimpleTestCase):
+ rf = RequestFactory()
+
+ def test_raise_exception(self):
+ request = self.rf.get("middleware_exceptions/view/")
+ with self.assertRaises(MiddlewareNotUsed):
+ MyMiddleware(lambda req: HttpResponse()).process_request(request)
+
+ @override_settings(MIDDLEWARE=["middleware_exceptions.tests.MyMiddleware"])
+ def test_log(self):
+ with self.assertLogs("django.request", "DEBUG") as cm:
+ self.client.get("/middleware_exceptions/view/")
+ self.assertEqual(
+ cm.records[0].getMessage(),
+ "MiddlewareNotUsed: 'middleware_exceptions.tests.MyMiddleware'",
+ )
+
+ @override_settings(
+ MIDDLEWARE=["middleware_exceptions.tests.MyMiddlewareWithExceptionMessage"]
+ )
+ def test_log_custom_message(self):
+ with self.assertLogs("django.request", "DEBUG") as cm:
+ self.client.get("/middleware_exceptions/view/")
+ self.assertEqual(
+ cm.records[0].getMessage(),
+ "MiddlewareNotUsed('middleware_exceptions.tests."
+ "MyMiddlewareWithExceptionMessage'): spam eggs",
+ )
+
+ @override_settings(
+ DEBUG=False,
+ MIDDLEWARE=["middleware_exceptions.tests.MyMiddleware"],
+ )
+ def test_do_not_log_when_debug_is_false(self):
+ with self.assertNoLogs("django.request", "DEBUG"):
+ self.client.get("/middleware_exceptions/view/")
+
+ @override_settings(
+ MIDDLEWARE=[
+ "middleware_exceptions.middleware.SyncAndAsyncMiddleware",
+ "middleware_exceptions.tests.MyMiddleware",
+ ]
+ )
+ async def test_async_and_sync_middleware_chain_async_call(self):
+ with self.assertLogs("django.request", "DEBUG") as cm:
+ response = await self.async_client.get("/middleware_exceptions/view/")
+ self.assertEqual(response.content, b"OK")
+ self.assertEqual(response.status_code, 200)
+ self.assertEqual(
+ cm.records[0].getMessage(),
+ "Asynchronous handler adapted for middleware "
+ "middleware_exceptions.tests.MyMiddleware.",
+ )
+ self.assertEqual(
+ cm.records[1].getMessage(),
+ "MiddlewareNotUsed: 'middleware_exceptions.tests.MyMiddleware'",
+ )
+
+
+@override_settings(
+ DEBUG=True,
+ ROOT_URLCONF="middleware_exceptions.urls",
+)
+class MiddlewareSyncAsyncTests(SimpleTestCase):
+ @override_settings(
+ MIDDLEWARE=[
+ "middleware_exceptions.middleware.PaymentMiddleware",
+ ]
+ )
+ def test_sync_middleware(self):
+ response = self.client.get("/middleware_exceptions/view/")
+ self.assertEqual(response.status_code, 402)
+
+ @override_settings(
+ MIDDLEWARE=[
+ "middleware_exceptions.middleware.DecoratedPaymentMiddleware",
+ ]
+ )
+ def test_sync_decorated_middleware(self):
+ response = self.client.get("/middleware_exceptions/view/")
+ self.assertEqual(response.status_code, 402)
+
+ @override_settings(
+ MIDDLEWARE=[
+ "middleware_exceptions.middleware.async_payment_middleware",
+ ]
+ )
+ def test_async_middleware(self):
+ with self.assertLogs("django.request", "DEBUG") as cm:
+ response = self.client.get("/middleware_exceptions/view/")
+ self.assertEqual(response.status_code, 402)
+ self.assertEqual(
+ cm.records[0].getMessage(),
+ "Synchronous handler adapted for middleware "
+ "middleware_exceptions.middleware.async_payment_middleware.",
+ )
+
+ @override_settings(
+ MIDDLEWARE=[
+ "middleware_exceptions.middleware.NotSyncOrAsyncMiddleware",
+ ]
+ )
+ def test_not_sync_or_async_middleware(self):
+ msg = (
+ "Middleware "
+ "middleware_exceptions.middleware.NotSyncOrAsyncMiddleware must "
+ "have at least one of sync_capable/async_capable set to True."
+ )
+ with self.assertRaisesMessage(RuntimeError, msg):
+ self.client.get("/middleware_exceptions/view/")
+
+ @override_settings(
+ MIDDLEWARE=[
+ "middleware_exceptions.middleware.PaymentMiddleware",
+ ]
+ )
+ async def test_sync_middleware_async(self):
+ with self.assertLogs("django.request", "DEBUG") as cm:
+ response = await self.async_client.get("/middleware_exceptions/view/")
+ self.assertEqual(response.status_code, 402)
+ self.assertEqual(
+ cm.records[0].getMessage(),
+ "Asynchronous handler adapted for middleware "
+ "middleware_exceptions.middleware.PaymentMiddleware.",
+ )
+
+ @override_settings(
+ MIDDLEWARE=[
+ "middleware_exceptions.middleware.async_payment_middleware",
+ ]
+ )
+ async def test_async_middleware_async(self):
+ with self.assertLogs("django.request", "WARNING") as cm:
+ response = await self.async_client.get("/middleware_exceptions/view/")
+ self.assertEqual(response.status_code, 402)
+ self.assertEqual(
+ cm.records[0].getMessage(),
+ "Payment Required: /middleware_exceptions/view/",
+ )
+
+ @override_settings(
+ DEBUG=False,
+ MIDDLEWARE=[
+ "middleware_exceptions.middleware.AsyncNoTemplateResponseMiddleware",
+ ],
+ )
+ def test_async_process_template_response_returns_none_with_sync_client(self):
+ msg = (
+ "AsyncNoTemplateResponseMiddleware.process_template_response "
+ "didn't return an HttpResponse object."
+ )
+ with self.assertRaisesMessage(ValueError, msg):
+ self.client.get("/middleware_exceptions/template_response/")
+
+ @override_settings(
+ MIDDLEWARE=[
+ "middleware_exceptions.middleware.SyncAndAsyncMiddleware",
+ ]
+ )
+ async def test_async_and_sync_middleware_async_call(self):
+ response = await self.async_client.get("/middleware_exceptions/view/")
+ self.assertEqual(response.content, b"OK")
+ self.assertEqual(response.status_code, 200)
+
+ @override_settings(
+ MIDDLEWARE=[
+ "middleware_exceptions.middleware.SyncAndAsyncMiddleware",
+ ]
+ )
+ def test_async_and_sync_middleware_sync_call(self):
+ response = self.client.get("/middleware_exceptions/view/")
+ self.assertEqual(response.content, b"OK")
+ self.assertEqual(response.status_code, 200)
+
+
+@override_settings(ROOT_URLCONF="middleware_exceptions.urls")
+class AsyncMiddlewareTests(SimpleTestCase):
+ @override_settings(
+ MIDDLEWARE=[
+ "middleware_exceptions.middleware.AsyncTemplateResponseMiddleware",
+ ]
+ )
+ async def test_process_template_response(self):
+ response = await self.async_client.get(
+ "/middleware_exceptions/template_response/"
+ )
+ self.assertEqual(
+ response.content,
+ b"template_response OK\nAsyncTemplateResponseMiddleware",
+ )
+
+ @override_settings(
+ MIDDLEWARE=[
+ "middleware_exceptions.middleware.AsyncNoTemplateResponseMiddleware",
+ ]
+ )
+ async def test_process_template_response_returns_none(self):
+ msg = (
+ "AsyncNoTemplateResponseMiddleware.process_template_response "
+ "didn't return an HttpResponse object. It returned None instead."
+ )
+ with self.assertRaisesMessage(ValueError, msg):
+ await self.async_client.get("/middleware_exceptions/template_response/")
+
+ @override_settings(
+ MIDDLEWARE=[
+ "middleware_exceptions.middleware.AsyncProcessExceptionMiddleware",
+ ]
+ )
+ async def test_exception_in_render_passed_to_process_exception(self):
+ response = await self.async_client.get(
+ "/middleware_exceptions/exception_in_render/"
+ )
+ self.assertEqual(response.content, b"Exception caught")
+
+ @override_settings(
+ MIDDLEWARE=[
+ "middleware_exceptions.middleware.AsyncProcessExceptionMiddleware",
+ ]
+ )
+ async def test_exception_in_async_render_passed_to_process_exception(self):
+ response = await self.async_client.get(
+ "/middleware_exceptions/async_exception_in_render/"
+ )
+ self.assertEqual(response.content, b"Exception caught")
+
+ @override_settings(
+ MIDDLEWARE=[
+ "middleware_exceptions.middleware.AsyncProcessExceptionMiddleware",
+ ]
+ )
+ async def test_view_exception_handled_by_process_exception(self):
+ response = await self.async_client.get("/middleware_exceptions/error/")
+ self.assertEqual(response.content, b"Exception caught")
+
+ @override_settings(
+ MIDDLEWARE=[
+ "middleware_exceptions.middleware.AsyncProcessViewMiddleware",
+ ]
+ )
+ async def test_process_view_return_response(self):
+ response = await self.async_client.get("/middleware_exceptions/view/")
+ self.assertEqual(response.content, b"Processed view normal_view")
diff --git a/testbed/django__django/tests/middleware_exceptions/urls.py b/testbed/django__django/tests/middleware_exceptions/urls.py
new file mode 100644
index 0000000000000000000000000000000000000000..80cbb2c21beb3df626a94187344aa74b34ff5a5a
--- /dev/null
+++ b/testbed/django__django/tests/middleware_exceptions/urls.py
@@ -0,0 +1,16 @@
+from django.urls import path
+
+from . import views
+
+urlpatterns = [
+ path("middleware_exceptions/view/", views.normal_view),
+ path("middleware_exceptions/error/", views.server_error),
+ path("middleware_exceptions/permission_denied/", views.permission_denied),
+ path("middleware_exceptions/exception_in_render/", views.exception_in_render),
+ path("middleware_exceptions/template_response/", views.template_response),
+ # Async views.
+ path(
+ "middleware_exceptions/async_exception_in_render/",
+ views.async_exception_in_render,
+ ),
+]
diff --git a/testbed/django__django/tests/middleware_exceptions/views.py b/testbed/django__django/tests/middleware_exceptions/views.py
new file mode 100644
index 0000000000000000000000000000000000000000..0f1595b2d6db13a39b6532ce3e41b5e9f717466d
--- /dev/null
+++ b/testbed/django__django/tests/middleware_exceptions/views.py
@@ -0,0 +1,39 @@
+from django.core.exceptions import PermissionDenied
+from django.http import HttpResponse
+from django.template import engines
+from django.template.response import TemplateResponse
+
+
+def normal_view(request):
+ return HttpResponse("OK")
+
+
+def template_response(request):
+ template = engines["django"].from_string(
+ "template_response OK{% for m in mw %}\n{{ m }}{% endfor %}"
+ )
+ return TemplateResponse(request, template, context={"mw": []})
+
+
+def server_error(request):
+ raise Exception("Error in view")
+
+
+def permission_denied(request):
+ raise PermissionDenied()
+
+
+def exception_in_render(request):
+ class CustomHttpResponse(HttpResponse):
+ def render(self):
+ raise Exception("Exception in HttpResponse.render()")
+
+ return CustomHttpResponse("Error")
+
+
+async def async_exception_in_render(request):
+ class CustomHttpResponse(HttpResponse):
+ async def render(self):
+ raise Exception("Exception in HttpResponse.render()")
+
+ return CustomHttpResponse("Error")
diff --git a/testbed/django__django/tests/migrate_signals/__init__.py b/testbed/django__django/tests/migrate_signals/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testbed/django__django/tests/migrate_signals/custom_migrations/0001_initial.py b/testbed/django__django/tests/migrate_signals/custom_migrations/0001_initial.py
new file mode 100644
index 0000000000000000000000000000000000000000..d90e477070625c90745fac085a11ee44e87afa8e
--- /dev/null
+++ b/testbed/django__django/tests/migrate_signals/custom_migrations/0001_initial.py
@@ -0,0 +1,12 @@
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+ operations = [
+ migrations.CreateModel(
+ "Signal",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ],
+ ),
+ ]
diff --git a/testbed/django__django/tests/migrate_signals/custom_migrations/__init__.py b/testbed/django__django/tests/migrate_signals/custom_migrations/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testbed/django__django/tests/migrate_signals/models.py b/testbed/django__django/tests/migrate_signals/models.py
new file mode 100644
index 0000000000000000000000000000000000000000..2cd71391fb7caca408e1465940600fcf33129f33
--- /dev/null
+++ b/testbed/django__django/tests/migrate_signals/models.py
@@ -0,0 +1,2 @@
+# This module has to exist, otherwise pre/post_migrate aren't sent for the
+# migrate_signals application.
diff --git a/testbed/django__django/tests/migrate_signals/tests.py b/testbed/django__django/tests/migrate_signals/tests.py
new file mode 100644
index 0000000000000000000000000000000000000000..71a93d3ad6df795a5e3ef3b65f7afc4cf7d317fd
--- /dev/null
+++ b/testbed/django__django/tests/migrate_signals/tests.py
@@ -0,0 +1,169 @@
+from io import StringIO
+
+from django.apps import apps
+from django.core import management
+from django.db import migrations
+from django.db.models import signals
+from django.test import TransactionTestCase, override_settings
+
+APP_CONFIG = apps.get_app_config("migrate_signals")
+SIGNAL_ARGS = [
+ "app_config",
+ "verbosity",
+ "interactive",
+ "using",
+ "stdout",
+ "plan",
+ "apps",
+]
+MIGRATE_DATABASE = "default"
+MIGRATE_VERBOSITY = 0
+MIGRATE_INTERACTIVE = False
+
+
+class Receiver:
+ def __init__(self, signal):
+ self.call_counter = 0
+ self.call_args = None
+ signal.connect(self, sender=APP_CONFIG)
+
+ def __call__(self, signal, sender, **kwargs):
+ self.call_counter += 1
+ self.call_args = kwargs
+
+
+class OneTimeReceiver:
+ """
+ Special receiver for handle the fact that test runner calls migrate for
+ several databases and several times for some of them.
+ """
+
+ def __init__(self, signal):
+ self.signal = signal
+ self.call_counter = 0
+ self.call_args = None
+ self.signal.connect(self, sender=APP_CONFIG)
+
+ def __call__(self, signal, sender, **kwargs):
+ # Although test runner calls migrate for several databases,
+ # testing for only one of them is quite sufficient.
+ if kwargs["using"] == MIGRATE_DATABASE:
+ self.call_counter += 1
+ self.call_args = kwargs
+ # we need to test only one call of migrate
+ self.signal.disconnect(self, sender=APP_CONFIG)
+
+
+# We connect receiver here and not in unit test code because we need to
+# connect receiver before test runner creates database. That is, sequence of
+# actions would be:
+#
+# 1. Test runner imports this module.
+# 2. We connect receiver.
+# 3. Test runner calls migrate for create default database.
+# 4. Test runner execute our unit test code.
+pre_migrate_receiver = OneTimeReceiver(signals.pre_migrate)
+post_migrate_receiver = OneTimeReceiver(signals.post_migrate)
+
+
+class MigrateSignalTests(TransactionTestCase):
+ available_apps = ["migrate_signals"]
+
+ def test_call_time(self):
+ self.assertEqual(pre_migrate_receiver.call_counter, 1)
+ self.assertEqual(post_migrate_receiver.call_counter, 1)
+
+ def test_args(self):
+ pre_migrate_receiver = Receiver(signals.pre_migrate)
+ post_migrate_receiver = Receiver(signals.post_migrate)
+ management.call_command(
+ "migrate",
+ database=MIGRATE_DATABASE,
+ verbosity=MIGRATE_VERBOSITY,
+ interactive=MIGRATE_INTERACTIVE,
+ stdout=StringIO("test_args"),
+ )
+
+ for receiver in [pre_migrate_receiver, post_migrate_receiver]:
+ with self.subTest(receiver=receiver):
+ args = receiver.call_args
+ self.assertEqual(receiver.call_counter, 1)
+ self.assertEqual(set(args), set(SIGNAL_ARGS))
+ self.assertEqual(args["app_config"], APP_CONFIG)
+ self.assertEqual(args["verbosity"], MIGRATE_VERBOSITY)
+ self.assertEqual(args["interactive"], MIGRATE_INTERACTIVE)
+ self.assertEqual(args["using"], "default")
+ self.assertIn("test_args", args["stdout"].getvalue())
+ self.assertEqual(args["plan"], [])
+ self.assertIsInstance(args["apps"], migrations.state.StateApps)
+
+ @override_settings(
+ MIGRATION_MODULES={"migrate_signals": "migrate_signals.custom_migrations"}
+ )
+ def test_migrations_only(self):
+ """
+ If all apps have migrations, migration signals should be sent.
+ """
+ pre_migrate_receiver = Receiver(signals.pre_migrate)
+ post_migrate_receiver = Receiver(signals.post_migrate)
+ management.call_command(
+ "migrate",
+ database=MIGRATE_DATABASE,
+ verbosity=MIGRATE_VERBOSITY,
+ interactive=MIGRATE_INTERACTIVE,
+ )
+ for receiver in [pre_migrate_receiver, post_migrate_receiver]:
+ args = receiver.call_args
+ self.assertEqual(receiver.call_counter, 1)
+ self.assertEqual(set(args), set(SIGNAL_ARGS))
+ self.assertEqual(args["app_config"], APP_CONFIG)
+ self.assertEqual(args["verbosity"], MIGRATE_VERBOSITY)
+ self.assertEqual(args["interactive"], MIGRATE_INTERACTIVE)
+ self.assertEqual(args["using"], "default")
+ self.assertIsInstance(args["plan"][0][0], migrations.Migration)
+ # The migration isn't applied backward.
+ self.assertFalse(args["plan"][0][1])
+ self.assertIsInstance(args["apps"], migrations.state.StateApps)
+ self.assertEqual(pre_migrate_receiver.call_args["apps"].get_models(), [])
+ self.assertEqual(
+ [
+ model._meta.label
+ for model in post_migrate_receiver.call_args["apps"].get_models()
+ ],
+ ["migrate_signals.Signal"],
+ )
+ # Migrating with an empty plan.
+ pre_migrate_receiver = Receiver(signals.pre_migrate)
+ post_migrate_receiver = Receiver(signals.post_migrate)
+ management.call_command(
+ "migrate",
+ database=MIGRATE_DATABASE,
+ verbosity=MIGRATE_VERBOSITY,
+ interactive=MIGRATE_INTERACTIVE,
+ )
+ self.assertEqual(
+ [
+ model._meta.label
+ for model in pre_migrate_receiver.call_args["apps"].get_models()
+ ],
+ ["migrate_signals.Signal"],
+ )
+ self.assertEqual(
+ [
+ model._meta.label
+ for model in post_migrate_receiver.call_args["apps"].get_models()
+ ],
+ ["migrate_signals.Signal"],
+ )
+ # Migrating with an empty plan and --check doesn't emit signals.
+ pre_migrate_receiver = Receiver(signals.pre_migrate)
+ post_migrate_receiver = Receiver(signals.post_migrate)
+ management.call_command(
+ "migrate",
+ database=MIGRATE_DATABASE,
+ verbosity=MIGRATE_VERBOSITY,
+ interactive=MIGRATE_INTERACTIVE,
+ check_unapplied=True,
+ )
+ self.assertEqual(pre_migrate_receiver.call_counter, 0)
+ self.assertEqual(post_migrate_receiver.call_counter, 0)
diff --git a/testbed/django__django/tests/migration_test_data_persistence/__init__.py b/testbed/django__django/tests/migration_test_data_persistence/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testbed/django__django/tests/migration_test_data_persistence/migrations/0001_initial.py b/testbed/django__django/tests/migration_test_data_persistence/migrations/0001_initial.py
new file mode 100644
index 0000000000000000000000000000000000000000..f9a75e29b8d772a85819e32363eef14eacf65db7
--- /dev/null
+++ b/testbed/django__django/tests/migration_test_data_persistence/migrations/0001_initial.py
@@ -0,0 +1,25 @@
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+ dependencies = []
+
+ operations = [
+ migrations.CreateModel(
+ name="Book",
+ fields=[
+ (
+ "id",
+ models.AutoField(
+ verbose_name="ID",
+ primary_key=True,
+ serialize=False,
+ auto_created=True,
+ ),
+ ),
+ ("title", models.CharField(max_length=100)),
+ ],
+ options={},
+ bases=(models.Model,),
+ ),
+ ]
diff --git a/testbed/django__django/tests/migration_test_data_persistence/migrations/0002_add_book.py b/testbed/django__django/tests/migration_test_data_persistence/migrations/0002_add_book.py
new file mode 100644
index 0000000000000000000000000000000000000000..c355428f34bcee28cb2aec0597326eb9e276604d
--- /dev/null
+++ b/testbed/django__django/tests/migration_test_data_persistence/migrations/0002_add_book.py
@@ -0,0 +1,19 @@
+from django.db import migrations
+
+
+def add_book(apps, schema_editor):
+ apps.get_model("migration_test_data_persistence", "Book").objects.using(
+ schema_editor.connection.alias,
+ ).create(
+ title="I Love Django",
+ )
+
+
+class Migration(migrations.Migration):
+ dependencies = [("migration_test_data_persistence", "0001_initial")]
+
+ operations = [
+ migrations.RunPython(
+ add_book,
+ ),
+ ]
diff --git a/testbed/django__django/tests/migration_test_data_persistence/migrations/__init__.py b/testbed/django__django/tests/migration_test_data_persistence/migrations/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testbed/django__django/tests/migration_test_data_persistence/models.py b/testbed/django__django/tests/migration_test_data_persistence/models.py
new file mode 100644
index 0000000000000000000000000000000000000000..c1572d5ddf3e7333455e095ffb04d9c62e235254
--- /dev/null
+++ b/testbed/django__django/tests/migration_test_data_persistence/models.py
@@ -0,0 +1,12 @@
+from django.db import models
+
+
+class Book(models.Model):
+ title = models.CharField(max_length=100)
+
+
+class Unmanaged(models.Model):
+ title = models.CharField(max_length=100)
+
+ class Meta:
+ managed = False
diff --git a/testbed/django__django/tests/migration_test_data_persistence/tests.py b/testbed/django__django/tests/migration_test_data_persistence/tests.py
new file mode 100644
index 0000000000000000000000000000000000000000..862a06c4a5279582b101c20b5ac33aef2051d1e3
--- /dev/null
+++ b/testbed/django__django/tests/migration_test_data_persistence/tests.py
@@ -0,0 +1,31 @@
+from django.test import TestCase, TransactionTestCase
+
+from .models import Book
+
+
+class MigrationDataPersistenceTestCase(TransactionTestCase):
+ """
+ Data loaded in migrations is available if
+ TransactionTestCase.serialized_rollback = True.
+ """
+
+ available_apps = ["migration_test_data_persistence"]
+ serialized_rollback = True
+
+ def test_persistence(self):
+ self.assertEqual(
+ Book.objects.count(),
+ 1,
+ )
+
+
+class MigrationDataNormalPersistenceTestCase(TestCase):
+ """
+ Data loaded in migrations is available on TestCase
+ """
+
+ def test_persistence(self):
+ self.assertEqual(
+ Book.objects.count(),
+ 1,
+ )
diff --git a/testbed/django__django/tests/migrations/__init__.py b/testbed/django__django/tests/migrations/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testbed/django__django/tests/migrations/deprecated_field_migrations/0001_initial.py b/testbed/django__django/tests/migrations/deprecated_field_migrations/0001_initial.py
new file mode 100644
index 0000000000000000000000000000000000000000..6f834ab87d363a11057d8f97c591b505c3c7c101
--- /dev/null
+++ b/testbed/django__django/tests/migrations/deprecated_field_migrations/0001_initial.py
@@ -0,0 +1,23 @@
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+ dependencies = []
+
+ operations = [
+ migrations.CreateModel(
+ name="IPAddressField",
+ fields=[
+ (
+ "id",
+ models.AutoField(
+ verbose_name="ID",
+ serialize=False,
+ auto_created=True,
+ primary_key=True,
+ ),
+ ),
+ ("ip", models.IPAddressField(null=True, blank=True)),
+ ],
+ ),
+ ]
diff --git a/testbed/django__django/tests/migrations/deprecated_field_migrations/0002_remove_ipaddressfield_ip.py b/testbed/django__django/tests/migrations/deprecated_field_migrations/0002_remove_ipaddressfield_ip.py
new file mode 100644
index 0000000000000000000000000000000000000000..5f831037b2bc5b1b62c432e6d1b59de1f12dba1d
--- /dev/null
+++ b/testbed/django__django/tests/migrations/deprecated_field_migrations/0002_remove_ipaddressfield_ip.py
@@ -0,0 +1,14 @@
+from django.db import migrations
+
+
+class Migration(migrations.Migration):
+ dependencies = [
+ ("migrations", "0001_initial"),
+ ]
+
+ operations = [
+ migrations.RemoveField(
+ model_name="ipaddressfield",
+ name="ip",
+ ),
+ ]
diff --git a/testbed/django__django/tests/migrations/deprecated_field_migrations/__init__.py b/testbed/django__django/tests/migrations/deprecated_field_migrations/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testbed/django__django/tests/migrations/faulty_migrations/__init__.py b/testbed/django__django/tests/migrations/faulty_migrations/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testbed/django__django/tests/migrations/faulty_migrations/file.py b/testbed/django__django/tests/migrations/faulty_migrations/file.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testbed/django__django/tests/migrations/faulty_migrations/namespace/foo/__init__.py b/testbed/django__django/tests/migrations/faulty_migrations/namespace/foo/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testbed/django__django/tests/migrations/migrations_test_apps/__init__.py b/testbed/django__django/tests/migrations/migrations_test_apps/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testbed/django__django/tests/migrations/migrations_test_apps/alter_fk/__init__.py b/testbed/django__django/tests/migrations/migrations_test_apps/alter_fk/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testbed/django__django/tests/migrations/migrations_test_apps/alter_fk/author_app/__init__.py b/testbed/django__django/tests/migrations/migrations_test_apps/alter_fk/author_app/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testbed/django__django/tests/migrations/migrations_test_apps/alter_fk/author_app/migrations/0001_initial.py b/testbed/django__django/tests/migrations/migrations_test_apps/alter_fk/author_app/migrations/0001_initial.py
new file mode 100644
index 0000000000000000000000000000000000000000..8910c6f115ac4a0d2a51973fbcdcd26deb0e9321
--- /dev/null
+++ b/testbed/django__django/tests/migrations/migrations_test_apps/alter_fk/author_app/migrations/0001_initial.py
@@ -0,0 +1,20 @@
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+ dependencies = []
+
+ operations = [
+ migrations.CreateModel(
+ name="Author",
+ fields=[
+ (
+ "id",
+ models.AutoField(
+ serialize=False, auto_created=True, primary_key=True
+ ),
+ ),
+ ("name", models.CharField(max_length=50)),
+ ],
+ ),
+ ]
diff --git a/testbed/django__django/tests/migrations/migrations_test_apps/alter_fk/author_app/migrations/0002_alter_id.py b/testbed/django__django/tests/migrations/migrations_test_apps/alter_fk/author_app/migrations/0002_alter_id.py
new file mode 100644
index 0000000000000000000000000000000000000000..66d875753403bf3daaac86a1523b981aa626229b
--- /dev/null
+++ b/testbed/django__django/tests/migrations/migrations_test_apps/alter_fk/author_app/migrations/0002_alter_id.py
@@ -0,0 +1,16 @@
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+ dependencies = [
+ ("author_app", "0001_initial"),
+ ("book_app", "0001_initial"), # Forces the book table to alter the FK
+ ]
+
+ operations = [
+ migrations.AlterField(
+ model_name="author",
+ name="id",
+ field=models.CharField(max_length=10, primary_key=True),
+ ),
+ ]
diff --git a/testbed/django__django/tests/migrations/migrations_test_apps/alter_fk/author_app/migrations/__init__.py b/testbed/django__django/tests/migrations/migrations_test_apps/alter_fk/author_app/migrations/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testbed/django__django/tests/migrations/migrations_test_apps/alter_fk/book_app/__init__.py b/testbed/django__django/tests/migrations/migrations_test_apps/alter_fk/book_app/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testbed/django__django/tests/migrations/migrations_test_apps/alter_fk/book_app/migrations/0001_initial.py b/testbed/django__django/tests/migrations/migrations_test_apps/alter_fk/book_app/migrations/0001_initial.py
new file mode 100644
index 0000000000000000000000000000000000000000..5ee7169220ed02b2934c30b85080ac0d7d0a9220
--- /dev/null
+++ b/testbed/django__django/tests/migrations/migrations_test_apps/alter_fk/book_app/migrations/0001_initial.py
@@ -0,0 +1,23 @@
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+ dependencies = [
+ ("author_app", "0001_initial"),
+ ]
+
+ operations = [
+ migrations.CreateModel(
+ name="Book",
+ fields=[
+ (
+ "id",
+ models.AutoField(
+ serialize=False, auto_created=True, primary_key=True
+ ),
+ ),
+ ("title", models.CharField(max_length=50)),
+ ("author", models.ForeignKey("author_app.Author", models.CASCADE)),
+ ],
+ ),
+ ]
diff --git a/testbed/django__django/tests/migrations/migrations_test_apps/alter_fk/book_app/migrations/__init__.py b/testbed/django__django/tests/migrations/migrations_test_apps/alter_fk/book_app/migrations/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testbed/django__django/tests/migrations/migrations_test_apps/conflicting_app_with_dependencies/__init__.py b/testbed/django__django/tests/migrations/migrations_test_apps/conflicting_app_with_dependencies/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testbed/django__django/tests/migrations/migrations_test_apps/conflicting_app_with_dependencies/migrations/0001_initial.py b/testbed/django__django/tests/migrations/migrations_test_apps/conflicting_app_with_dependencies/migrations/0001_initial.py
new file mode 100644
index 0000000000000000000000000000000000000000..42aadab7a003546192cdd83e28fa7e12b9eb4a38
--- /dev/null
+++ b/testbed/django__django/tests/migrations/migrations_test_apps/conflicting_app_with_dependencies/migrations/0001_initial.py
@@ -0,0 +1,23 @@
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+ operations = [
+ migrations.CreateModel(
+ "Author",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ("name", models.CharField(max_length=255)),
+ ("slug", models.SlugField(null=True)),
+ ("age", models.IntegerField(default=0)),
+ ("silly_field", models.BooleanField(default=False)),
+ ],
+ ),
+ migrations.CreateModel(
+ "Tribble",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ("fluffy", models.BooleanField(default=True)),
+ ],
+ ),
+ ]
diff --git a/testbed/django__django/tests/migrations/migrations_test_apps/conflicting_app_with_dependencies/migrations/0002_conflicting_second.py b/testbed/django__django/tests/migrations/migrations_test_apps/conflicting_app_with_dependencies/migrations/0002_conflicting_second.py
new file mode 100644
index 0000000000000000000000000000000000000000..c176e1f0c3ab2fbbf5289f1830abc0517aaa917f
--- /dev/null
+++ b/testbed/django__django/tests/migrations/migrations_test_apps/conflicting_app_with_dependencies/migrations/0002_conflicting_second.py
@@ -0,0 +1,16 @@
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+ dependencies = [
+ ("conflicting_app_with_dependencies", "0001_initial"),
+ ]
+
+ operations = [
+ migrations.CreateModel(
+ "Something",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ],
+ )
+ ]
diff --git a/testbed/django__django/tests/migrations/migrations_test_apps/conflicting_app_with_dependencies/migrations/0002_second.py b/testbed/django__django/tests/migrations/migrations_test_apps/conflicting_app_with_dependencies/migrations/0002_second.py
new file mode 100644
index 0000000000000000000000000000000000000000..86c12e7c2ab5650b3cd88059400aeb07f91f3771
--- /dev/null
+++ b/testbed/django__django/tests/migrations/migrations_test_apps/conflicting_app_with_dependencies/migrations/0002_second.py
@@ -0,0 +1,20 @@
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+ dependencies = [
+ ("conflicting_app_with_dependencies", "0001_initial"),
+ ("migrated_app", "0001_initial"),
+ ]
+
+ operations = [
+ migrations.DeleteModel("Tribble"),
+ migrations.RemoveField("Author", "silly_field"),
+ migrations.AddField("Author", "rating", models.IntegerField(default=0)),
+ migrations.CreateModel(
+ "Book",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ],
+ ),
+ ]
diff --git a/testbed/django__django/tests/migrations/migrations_test_apps/conflicting_app_with_dependencies/migrations/__init__.py b/testbed/django__django/tests/migrations/migrations_test_apps/conflicting_app_with_dependencies/migrations/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testbed/django__django/tests/migrations/migrations_test_apps/lookuperror_a/__init__.py b/testbed/django__django/tests/migrations/migrations_test_apps/lookuperror_a/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testbed/django__django/tests/migrations/migrations_test_apps/lookuperror_a/migrations/0001_initial.py b/testbed/django__django/tests/migrations/migrations_test_apps/lookuperror_a/migrations/0001_initial.py
new file mode 100644
index 0000000000000000000000000000000000000000..de3a217656ba04d4f6345a41cbbc311ff744de72
--- /dev/null
+++ b/testbed/django__django/tests/migrations/migrations_test_apps/lookuperror_a/migrations/0001_initial.py
@@ -0,0 +1,22 @@
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+ dependencies = []
+
+ operations = [
+ migrations.CreateModel(
+ name="A1",
+ fields=[
+ (
+ "id",
+ models.AutoField(
+ serialize=False,
+ verbose_name="ID",
+ auto_created=True,
+ primary_key=True,
+ ),
+ ),
+ ],
+ ),
+ ]
diff --git a/testbed/django__django/tests/migrations/migrations_test_apps/lookuperror_a/migrations/0002_a2.py b/testbed/django__django/tests/migrations/migrations_test_apps/lookuperror_a/migrations/0002_a2.py
new file mode 100644
index 0000000000000000000000000000000000000000..abd02fa857b1929c96d818ffc18d4b8441e5fd3d
--- /dev/null
+++ b/testbed/django__django/tests/migrations/migrations_test_apps/lookuperror_a/migrations/0002_a2.py
@@ -0,0 +1,24 @@
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+ dependencies = [
+ ("lookuperror_a", "0001_initial"),
+ ]
+
+ operations = [
+ migrations.CreateModel(
+ name="A2",
+ fields=[
+ (
+ "id",
+ models.AutoField(
+ verbose_name="ID",
+ primary_key=True,
+ serialize=False,
+ auto_created=True,
+ ),
+ ),
+ ],
+ ),
+ ]
diff --git a/testbed/django__django/tests/migrations/migrations_test_apps/lookuperror_a/migrations/0003_a3.py b/testbed/django__django/tests/migrations/migrations_test_apps/lookuperror_a/migrations/0003_a3.py
new file mode 100644
index 0000000000000000000000000000000000000000..43cf2d9fe0f1055183d0f593318d7c65d9dc417f
--- /dev/null
+++ b/testbed/django__django/tests/migrations/migrations_test_apps/lookuperror_a/migrations/0003_a3.py
@@ -0,0 +1,28 @@
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+ dependencies = [
+ ("lookuperror_c", "0002_c2"),
+ ("lookuperror_b", "0002_b2"),
+ ("lookuperror_a", "0002_a2"),
+ ]
+
+ operations = [
+ migrations.CreateModel(
+ name="A3",
+ fields=[
+ (
+ "id",
+ models.AutoField(
+ serialize=False,
+ auto_created=True,
+ primary_key=True,
+ verbose_name="ID",
+ ),
+ ),
+ ("b2", models.ForeignKey("lookuperror_b.B2", models.CASCADE)),
+ ("c2", models.ForeignKey("lookuperror_c.C2", models.CASCADE)),
+ ],
+ ),
+ ]
diff --git a/testbed/django__django/tests/migrations/migrations_test_apps/lookuperror_a/migrations/0004_a4.py b/testbed/django__django/tests/migrations/migrations_test_apps/lookuperror_a/migrations/0004_a4.py
new file mode 100644
index 0000000000000000000000000000000000000000..f26e090fb01f845c880f3797e0c2fd14b6a90337
--- /dev/null
+++ b/testbed/django__django/tests/migrations/migrations_test_apps/lookuperror_a/migrations/0004_a4.py
@@ -0,0 +1,24 @@
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+ dependencies = [
+ ("lookuperror_a", "0003_a3"),
+ ]
+
+ operations = [
+ migrations.CreateModel(
+ name="A4",
+ fields=[
+ (
+ "id",
+ models.AutoField(
+ auto_created=True,
+ serialize=False,
+ verbose_name="ID",
+ primary_key=True,
+ ),
+ ),
+ ],
+ ),
+ ]
diff --git a/testbed/django__django/tests/migrations/migrations_test_apps/lookuperror_a/migrations/__init__.py b/testbed/django__django/tests/migrations/migrations_test_apps/lookuperror_a/migrations/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testbed/django__django/tests/migrations/migrations_test_apps/lookuperror_a/models.py b/testbed/django__django/tests/migrations/migrations_test_apps/lookuperror_a/models.py
new file mode 100644
index 0000000000000000000000000000000000000000..fbc4cb68097e79d86c3f77070b8bc3bae653b628
--- /dev/null
+++ b/testbed/django__django/tests/migrations/migrations_test_apps/lookuperror_a/models.py
@@ -0,0 +1,18 @@
+from django.db import models
+
+
+class A1(models.Model):
+ pass
+
+
+class A2(models.Model):
+ pass
+
+
+class A3(models.Model):
+ b2 = models.ForeignKey("lookuperror_b.B2", models.CASCADE)
+ c2 = models.ForeignKey("lookuperror_c.C2", models.CASCADE)
+
+
+class A4(models.Model):
+ pass
diff --git a/testbed/django__django/tests/migrations/migrations_test_apps/lookuperror_b/__init__.py b/testbed/django__django/tests/migrations/migrations_test_apps/lookuperror_b/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testbed/django__django/tests/migrations/migrations_test_apps/lookuperror_b/migrations/0001_initial.py b/testbed/django__django/tests/migrations/migrations_test_apps/lookuperror_b/migrations/0001_initial.py
new file mode 100644
index 0000000000000000000000000000000000000000..1479afe84d07b3e23bea0307c5ed4e9dcf1544b6
--- /dev/null
+++ b/testbed/django__django/tests/migrations/migrations_test_apps/lookuperror_b/migrations/0001_initial.py
@@ -0,0 +1,22 @@
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+ dependencies = []
+
+ operations = [
+ migrations.CreateModel(
+ name="B1",
+ fields=[
+ (
+ "id",
+ models.AutoField(
+ serialize=False,
+ auto_created=True,
+ primary_key=True,
+ verbose_name="ID",
+ ),
+ ),
+ ],
+ ),
+ ]
diff --git a/testbed/django__django/tests/migrations/migrations_test_apps/lookuperror_b/migrations/0002_b2.py b/testbed/django__django/tests/migrations/migrations_test_apps/lookuperror_b/migrations/0002_b2.py
new file mode 100644
index 0000000000000000000000000000000000000000..6c506da6738fe2e2bb800950bd96ca1fd7a8ece3
--- /dev/null
+++ b/testbed/django__django/tests/migrations/migrations_test_apps/lookuperror_b/migrations/0002_b2.py
@@ -0,0 +1,26 @@
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+ dependencies = [
+ ("lookuperror_a", "0002_a2"),
+ ("lookuperror_b", "0001_initial"),
+ ]
+
+ operations = [
+ migrations.CreateModel(
+ name="B2",
+ fields=[
+ (
+ "id",
+ models.AutoField(
+ primary_key=True,
+ verbose_name="ID",
+ auto_created=True,
+ serialize=False,
+ ),
+ ),
+ ("a1", models.ForeignKey("lookuperror_a.A1", models.CASCADE)),
+ ],
+ ),
+ ]
diff --git a/testbed/django__django/tests/migrations/migrations_test_apps/lookuperror_b/migrations/0003_b3.py b/testbed/django__django/tests/migrations/migrations_test_apps/lookuperror_b/migrations/0003_b3.py
new file mode 100644
index 0000000000000000000000000000000000000000..adfcd171bb51083efe821a2ca4df826fe9b1fa67
--- /dev/null
+++ b/testbed/django__django/tests/migrations/migrations_test_apps/lookuperror_b/migrations/0003_b3.py
@@ -0,0 +1,24 @@
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+ dependencies = [
+ ("lookuperror_b", "0002_b2"),
+ ]
+
+ operations = [
+ migrations.CreateModel(
+ name="B3",
+ fields=[
+ (
+ "id",
+ models.AutoField(
+ verbose_name="ID",
+ serialize=False,
+ primary_key=True,
+ auto_created=True,
+ ),
+ ),
+ ],
+ ),
+ ]
diff --git a/testbed/django__django/tests/migrations/migrations_test_apps/lookuperror_b/migrations/__init__.py b/testbed/django__django/tests/migrations/migrations_test_apps/lookuperror_b/migrations/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testbed/django__django/tests/migrations/migrations_test_apps/lookuperror_b/models.py b/testbed/django__django/tests/migrations/migrations_test_apps/lookuperror_b/models.py
new file mode 100644
index 0000000000000000000000000000000000000000..0bca4e68ec732e6b892f80c86cf8b747568cf914
--- /dev/null
+++ b/testbed/django__django/tests/migrations/migrations_test_apps/lookuperror_b/models.py
@@ -0,0 +1,13 @@
+from django.db import models
+
+
+class B1(models.Model):
+ pass
+
+
+class B2(models.Model):
+ a1 = models.ForeignKey("lookuperror_a.A1", models.CASCADE)
+
+
+class B3(models.Model):
+ pass
diff --git a/testbed/django__django/tests/migrations/migrations_test_apps/lookuperror_c/__init__.py b/testbed/django__django/tests/migrations/migrations_test_apps/lookuperror_c/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testbed/django__django/tests/migrations/migrations_test_apps/lookuperror_c/migrations/0001_initial.py b/testbed/django__django/tests/migrations/migrations_test_apps/lookuperror_c/migrations/0001_initial.py
new file mode 100644
index 0000000000000000000000000000000000000000..1db74afb846bf15266e1e1d3863c59155b5d5b20
--- /dev/null
+++ b/testbed/django__django/tests/migrations/migrations_test_apps/lookuperror_c/migrations/0001_initial.py
@@ -0,0 +1,22 @@
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+ dependencies = []
+
+ operations = [
+ migrations.CreateModel(
+ name="C1",
+ fields=[
+ (
+ "id",
+ models.AutoField(
+ serialize=False,
+ verbose_name="ID",
+ auto_created=True,
+ primary_key=True,
+ ),
+ ),
+ ],
+ ),
+ ]
diff --git a/testbed/django__django/tests/migrations/migrations_test_apps/lookuperror_c/migrations/0002_c2.py b/testbed/django__django/tests/migrations/migrations_test_apps/lookuperror_c/migrations/0002_c2.py
new file mode 100644
index 0000000000000000000000000000000000000000..0e3fd72db3d89bd5ab0c0761a25306103f3507c4
--- /dev/null
+++ b/testbed/django__django/tests/migrations/migrations_test_apps/lookuperror_c/migrations/0002_c2.py
@@ -0,0 +1,26 @@
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+ dependencies = [
+ ("lookuperror_a", "0002_a2"),
+ ("lookuperror_c", "0001_initial"),
+ ]
+
+ operations = [
+ migrations.CreateModel(
+ name="C2",
+ fields=[
+ (
+ "id",
+ models.AutoField(
+ auto_created=True,
+ verbose_name="ID",
+ primary_key=True,
+ serialize=False,
+ ),
+ ),
+ ("a1", models.ForeignKey("lookuperror_a.A1", models.CASCADE)),
+ ],
+ ),
+ ]
diff --git a/testbed/django__django/tests/migrations/migrations_test_apps/lookuperror_c/migrations/0003_c3.py b/testbed/django__django/tests/migrations/migrations_test_apps/lookuperror_c/migrations/0003_c3.py
new file mode 100644
index 0000000000000000000000000000000000000000..4229faea6d119f32a309fb5a2dea66ea0f5e5583
--- /dev/null
+++ b/testbed/django__django/tests/migrations/migrations_test_apps/lookuperror_c/migrations/0003_c3.py
@@ -0,0 +1,24 @@
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+ dependencies = [
+ ("lookuperror_c", "0002_c2"),
+ ]
+
+ operations = [
+ migrations.CreateModel(
+ name="C3",
+ fields=[
+ (
+ "id",
+ models.AutoField(
+ auto_created=True,
+ serialize=False,
+ verbose_name="ID",
+ primary_key=True,
+ ),
+ ),
+ ],
+ ),
+ ]
diff --git a/testbed/django__django/tests/migrations/migrations_test_apps/lookuperror_c/migrations/__init__.py b/testbed/django__django/tests/migrations/migrations_test_apps/lookuperror_c/migrations/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testbed/django__django/tests/migrations/migrations_test_apps/lookuperror_c/models.py b/testbed/django__django/tests/migrations/migrations_test_apps/lookuperror_c/models.py
new file mode 100644
index 0000000000000000000000000000000000000000..dbf5bca6b81997abf5b592fd5677e89437565707
--- /dev/null
+++ b/testbed/django__django/tests/migrations/migrations_test_apps/lookuperror_c/models.py
@@ -0,0 +1,13 @@
+from django.db import models
+
+
+class C1(models.Model):
+ pass
+
+
+class C2(models.Model):
+ a1 = models.ForeignKey("lookuperror_a.A1", models.CASCADE)
+
+
+class C3(models.Model):
+ pass
diff --git a/testbed/django__django/tests/migrations/migrations_test_apps/migrated_app/__init__.py b/testbed/django__django/tests/migrations/migrations_test_apps/migrated_app/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testbed/django__django/tests/migrations/migrations_test_apps/migrated_app/migrations/0001_initial.py b/testbed/django__django/tests/migrations/migrations_test_apps/migrated_app/migrations/0001_initial.py
new file mode 100644
index 0000000000000000000000000000000000000000..42aadab7a003546192cdd83e28fa7e12b9eb4a38
--- /dev/null
+++ b/testbed/django__django/tests/migrations/migrations_test_apps/migrated_app/migrations/0001_initial.py
@@ -0,0 +1,23 @@
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+ operations = [
+ migrations.CreateModel(
+ "Author",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ("name", models.CharField(max_length=255)),
+ ("slug", models.SlugField(null=True)),
+ ("age", models.IntegerField(default=0)),
+ ("silly_field", models.BooleanField(default=False)),
+ ],
+ ),
+ migrations.CreateModel(
+ "Tribble",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ("fluffy", models.BooleanField(default=True)),
+ ],
+ ),
+ ]
diff --git a/testbed/django__django/tests/migrations/migrations_test_apps/migrated_app/migrations/__init__.py b/testbed/django__django/tests/migrations/migrations_test_apps/migrated_app/migrations/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testbed/django__django/tests/migrations/migrations_test_apps/migrated_app/models.py b/testbed/django__django/tests/migrations/migrations_test_apps/migrated_app/models.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testbed/django__django/tests/migrations/migrations_test_apps/migrated_unapplied_app/__init__.py b/testbed/django__django/tests/migrations/migrations_test_apps/migrated_unapplied_app/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testbed/django__django/tests/migrations/migrations_test_apps/migrated_unapplied_app/migrations/0001_initial.py b/testbed/django__django/tests/migrations/migrations_test_apps/migrated_unapplied_app/migrations/0001_initial.py
new file mode 100644
index 0000000000000000000000000000000000000000..809b5673c877a85bb233057229b6d366b1a5980c
--- /dev/null
+++ b/testbed/django__django/tests/migrations/migrations_test_apps/migrated_unapplied_app/migrations/0001_initial.py
@@ -0,0 +1,16 @@
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+ operations = [
+ migrations.CreateModel(
+ "OtherAuthor",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ("name", models.CharField(max_length=255)),
+ ("slug", models.SlugField(null=True)),
+ ("age", models.IntegerField(default=0)),
+ ("silly_field", models.BooleanField(default=False)),
+ ],
+ ),
+ ]
diff --git a/testbed/django__django/tests/migrations/migrations_test_apps/migrated_unapplied_app/migrations/__init__.py b/testbed/django__django/tests/migrations/migrations_test_apps/migrated_unapplied_app/migrations/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testbed/django__django/tests/migrations/migrations_test_apps/migrated_unapplied_app/models.py b/testbed/django__django/tests/migrations/migrations_test_apps/migrated_unapplied_app/models.py
new file mode 100644
index 0000000000000000000000000000000000000000..efb71e637fb13c7ef9b5a3e883f1e4bd6801f7d8
--- /dev/null
+++ b/testbed/django__django/tests/migrations/migrations_test_apps/migrated_unapplied_app/models.py
@@ -0,0 +1,12 @@
+from django.db import models
+
+
+class OtherAuthor(models.Model):
+ id = models.AutoField(primary_key=True)
+ name = models.CharField(max_length=255)
+ slug = models.SlugField(null=True)
+ age = models.IntegerField(default=0)
+ silly_field = models.BooleanField(default=False)
+
+ class Meta:
+ app_label = "migrated_unapplied_app"
diff --git a/testbed/django__django/tests/migrations/migrations_test_apps/mutate_state_a/__init__.py b/testbed/django__django/tests/migrations/migrations_test_apps/mutate_state_a/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testbed/django__django/tests/migrations/migrations_test_apps/mutate_state_a/migrations/0001_initial.py b/testbed/django__django/tests/migrations/migrations_test_apps/mutate_state_a/migrations/0001_initial.py
new file mode 100644
index 0000000000000000000000000000000000000000..a71e330166e6946e8607e7663892706ffc4cdfa4
--- /dev/null
+++ b/testbed/django__django/tests/migrations/migrations_test_apps/mutate_state_a/migrations/0001_initial.py
@@ -0,0 +1,29 @@
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+ dependencies = [
+ ("mutate_state_b", "0001_initial"),
+ ]
+
+ operations = [
+ migrations.SeparateDatabaseAndState(
+ [],
+ [
+ migrations.CreateModel(
+ name="A",
+ fields=[
+ (
+ "id",
+ models.AutoField(
+ serialize=False,
+ verbose_name="ID",
+ auto_created=True,
+ primary_key=True,
+ ),
+ ),
+ ],
+ ),
+ ],
+ )
+ ]
diff --git a/testbed/django__django/tests/migrations/migrations_test_apps/mutate_state_a/migrations/__init__.py b/testbed/django__django/tests/migrations/migrations_test_apps/mutate_state_a/migrations/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testbed/django__django/tests/migrations/migrations_test_apps/mutate_state_b/__init__.py b/testbed/django__django/tests/migrations/migrations_test_apps/mutate_state_b/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testbed/django__django/tests/migrations/migrations_test_apps/mutate_state_b/migrations/0001_initial.py b/testbed/django__django/tests/migrations/migrations_test_apps/mutate_state_b/migrations/0001_initial.py
new file mode 100644
index 0000000000000000000000000000000000000000..aa8550e4f4d9191c31f63428a99e803aa342c244
--- /dev/null
+++ b/testbed/django__django/tests/migrations/migrations_test_apps/mutate_state_b/migrations/0001_initial.py
@@ -0,0 +1,27 @@
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+ dependencies = []
+
+ operations = [
+ migrations.SeparateDatabaseAndState(
+ [],
+ [
+ migrations.CreateModel(
+ name="B",
+ fields=[
+ (
+ "id",
+ models.AutoField(
+ serialize=False,
+ verbose_name="ID",
+ auto_created=True,
+ primary_key=True,
+ ),
+ ),
+ ],
+ ),
+ ],
+ )
+ ]
diff --git a/testbed/django__django/tests/migrations/migrations_test_apps/mutate_state_b/migrations/0002_add_field.py b/testbed/django__django/tests/migrations/migrations_test_apps/mutate_state_b/migrations/0002_add_field.py
new file mode 100644
index 0000000000000000000000000000000000000000..15278e5dd7b61f8f78ada4b04d46faf853b0ad84
--- /dev/null
+++ b/testbed/django__django/tests/migrations/migrations_test_apps/mutate_state_b/migrations/0002_add_field.py
@@ -0,0 +1,20 @@
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+ dependencies = [
+ ("mutate_state_b", "0001_initial"),
+ ]
+
+ operations = [
+ migrations.SeparateDatabaseAndState(
+ [],
+ [
+ migrations.AddField(
+ model_name="B",
+ name="added",
+ field=models.TextField(),
+ ),
+ ],
+ )
+ ]
diff --git a/testbed/django__django/tests/migrations/migrations_test_apps/mutate_state_b/migrations/__init__.py b/testbed/django__django/tests/migrations/migrations_test_apps/mutate_state_b/migrations/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testbed/django__django/tests/migrations/migrations_test_apps/normal/__init__.py b/testbed/django__django/tests/migrations/migrations_test_apps/normal/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testbed/django__django/tests/migrations/migrations_test_apps/unmigrated_app/__init__.py b/testbed/django__django/tests/migrations/migrations_test_apps/unmigrated_app/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testbed/django__django/tests/migrations/migrations_test_apps/unmigrated_app/models.py b/testbed/django__django/tests/migrations/migrations_test_apps/unmigrated_app/models.py
new file mode 100644
index 0000000000000000000000000000000000000000..03d397c45b755a9e54d925500a5283dbf12bfbb5
--- /dev/null
+++ b/testbed/django__django/tests/migrations/migrations_test_apps/unmigrated_app/models.py
@@ -0,0 +1,7 @@
+from django.db import models
+
+
+class SillyModel(models.Model):
+ silly_field = models.BooleanField(default=False)
+ silly_tribble = models.ForeignKey("migrations.Tribble", models.CASCADE)
+ is_trouble = models.BooleanField(default=True)
diff --git a/testbed/django__django/tests/migrations/migrations_test_apps/unmigrated_app_simple/__init__.py b/testbed/django__django/tests/migrations/migrations_test_apps/unmigrated_app_simple/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testbed/django__django/tests/migrations/migrations_test_apps/unmigrated_app_simple/models.py b/testbed/django__django/tests/migrations/migrations_test_apps/unmigrated_app_simple/models.py
new file mode 100644
index 0000000000000000000000000000000000000000..5119205b9ad01a2a86cab33462bd26f25ea6c177
--- /dev/null
+++ b/testbed/django__django/tests/migrations/migrations_test_apps/unmigrated_app_simple/models.py
@@ -0,0 +1,10 @@
+from django.db import models
+
+
+class UnmigratedModel(models.Model):
+ """
+ A model that is in a migration-less app (which this app is
+ if its migrations directory has not been repointed)
+ """
+
+ pass
diff --git a/testbed/django__django/tests/migrations/migrations_test_apps/unmigrated_app_syncdb/__init__.py b/testbed/django__django/tests/migrations/migrations_test_apps/unmigrated_app_syncdb/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testbed/django__django/tests/migrations/migrations_test_apps/unmigrated_app_syncdb/models.py b/testbed/django__django/tests/migrations/migrations_test_apps/unmigrated_app_syncdb/models.py
new file mode 100644
index 0000000000000000000000000000000000000000..9f3179cd0d6de099be0e44cc8eb222f7e62ec22c
--- /dev/null
+++ b/testbed/django__django/tests/migrations/migrations_test_apps/unmigrated_app_syncdb/models.py
@@ -0,0 +1,9 @@
+from django.db import models
+
+
+class Classroom(models.Model):
+ pass
+
+
+class Lesson(models.Model):
+ classroom = models.ForeignKey(Classroom, on_delete=models.CASCADE)
diff --git a/testbed/django__django/tests/migrations/migrations_test_apps/unspecified_app_with_conflict/__init__.py b/testbed/django__django/tests/migrations/migrations_test_apps/unspecified_app_with_conflict/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testbed/django__django/tests/migrations/migrations_test_apps/unspecified_app_with_conflict/migrations/0001_initial.py b/testbed/django__django/tests/migrations/migrations_test_apps/unspecified_app_with_conflict/migrations/0001_initial.py
new file mode 100644
index 0000000000000000000000000000000000000000..42aadab7a003546192cdd83e28fa7e12b9eb4a38
--- /dev/null
+++ b/testbed/django__django/tests/migrations/migrations_test_apps/unspecified_app_with_conflict/migrations/0001_initial.py
@@ -0,0 +1,23 @@
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+ operations = [
+ migrations.CreateModel(
+ "Author",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ("name", models.CharField(max_length=255)),
+ ("slug", models.SlugField(null=True)),
+ ("age", models.IntegerField(default=0)),
+ ("silly_field", models.BooleanField(default=False)),
+ ],
+ ),
+ migrations.CreateModel(
+ "Tribble",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ("fluffy", models.BooleanField(default=True)),
+ ],
+ ),
+ ]
diff --git a/testbed/django__django/tests/migrations/migrations_test_apps/unspecified_app_with_conflict/migrations/0002_conflicting_second.py b/testbed/django__django/tests/migrations/migrations_test_apps/unspecified_app_with_conflict/migrations/0002_conflicting_second.py
new file mode 100644
index 0000000000000000000000000000000000000000..5817f30692b86c05e37688b12cde3d25fdf5a7c7
--- /dev/null
+++ b/testbed/django__django/tests/migrations/migrations_test_apps/unspecified_app_with_conflict/migrations/0002_conflicting_second.py
@@ -0,0 +1,14 @@
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+ dependencies = [("unspecified_app_with_conflict", "0001_initial")]
+
+ operations = [
+ migrations.CreateModel(
+ "Something",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ],
+ )
+ ]
diff --git a/testbed/django__django/tests/migrations/migrations_test_apps/unspecified_app_with_conflict/migrations/0002_second.py b/testbed/django__django/tests/migrations/migrations_test_apps/unspecified_app_with_conflict/migrations/0002_second.py
new file mode 100644
index 0000000000000000000000000000000000000000..506b3306c2b08cfa5972a230d8d0f29c5efed1e1
--- /dev/null
+++ b/testbed/django__django/tests/migrations/migrations_test_apps/unspecified_app_with_conflict/migrations/0002_second.py
@@ -0,0 +1,17 @@
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+ dependencies = [("unspecified_app_with_conflict", "0001_initial")]
+
+ operations = [
+ migrations.DeleteModel("Tribble"),
+ migrations.RemoveField("Author", "silly_field"),
+ migrations.AddField("Author", "rating", models.IntegerField(default=0)),
+ migrations.CreateModel(
+ "Book",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ],
+ ),
+ ]
diff --git a/testbed/django__django/tests/migrations/migrations_test_apps/unspecified_app_with_conflict/migrations/__init__.py b/testbed/django__django/tests/migrations/migrations_test_apps/unspecified_app_with_conflict/migrations/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testbed/django__django/tests/migrations/migrations_test_apps/unspecified_app_with_conflict/models.py b/testbed/django__django/tests/migrations/migrations_test_apps/unspecified_app_with_conflict/models.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testbed/django__django/tests/migrations/migrations_test_apps/with_package_model/__init__.py b/testbed/django__django/tests/migrations/migrations_test_apps/with_package_model/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testbed/django__django/tests/migrations/migrations_test_apps/with_package_model/models/__init__.py b/testbed/django__django/tests/migrations/migrations_test_apps/with_package_model/models/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testbed/django__django/tests/migrations/migrations_test_apps/without_init_file/__init__.py b/testbed/django__django/tests/migrations/migrations_test_apps/without_init_file/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testbed/django__django/tests/migrations/migrations_test_apps/without_init_file/migrations/.keep b/testbed/django__django/tests/migrations/migrations_test_apps/without_init_file/migrations/.keep
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testbed/django__django/tests/migrations/models.py b/testbed/django__django/tests/migrations/models.py
new file mode 100644
index 0000000000000000000000000000000000000000..0d728561d02969758f1e0f539b623f1cdf1d03f1
--- /dev/null
+++ b/testbed/django__django/tests/migrations/models.py
@@ -0,0 +1,70 @@
+from django.apps.registry import Apps
+from django.db import models
+
+
+class CustomModelBase(models.base.ModelBase):
+ pass
+
+
+class ModelWithCustomBase(models.Model, metaclass=CustomModelBase):
+ pass
+
+
+class UnicodeModel(models.Model):
+ title = models.CharField("ÚÑÍ¢ÓÐÉ", max_length=20, default="“Ðjáñgó”")
+
+ class Meta:
+ # Disable auto loading of this model as we load it on our own
+ apps = Apps()
+ verbose_name = "úñí©óðé µóðéø"
+ verbose_name_plural = "úñí©óðé µóðéøß"
+
+ def __str__(self):
+ return self.title
+
+
+class Unserializable:
+ """
+ An object that migration doesn't know how to serialize.
+ """
+
+ pass
+
+
+class UnserializableModel(models.Model):
+ title = models.CharField(max_length=20, default=Unserializable())
+
+ class Meta:
+ # Disable auto loading of this model as we load it on our own
+ apps = Apps()
+
+
+class UnmigratedModel(models.Model):
+ """
+ A model that is in a migration-less app (which this app is
+ if its migrations directory has not been repointed)
+ """
+
+ pass
+
+
+class EmptyManager(models.Manager):
+ use_in_migrations = True
+
+
+class FoodQuerySet(models.query.QuerySet):
+ pass
+
+
+class BaseFoodManager(models.Manager):
+ def __init__(self, a, b, c=1, d=2):
+ super().__init__()
+ self.args = (a, b, c, d)
+
+
+class FoodManager(BaseFoodManager.from_queryset(FoodQuerySet)):
+ use_in_migrations = True
+
+
+class NoMigrationFoodManager(BaseFoodManager.from_queryset(FoodQuerySet)):
+ pass
diff --git a/testbed/django__django/tests/migrations/related_models_app/__init__.py b/testbed/django__django/tests/migrations/related_models_app/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testbed/django__django/tests/migrations/routers.py b/testbed/django__django/tests/migrations/routers.py
new file mode 100644
index 0000000000000000000000000000000000000000..211c189772cb3184308c24af236e8e9268d1228f
--- /dev/null
+++ b/testbed/django__django/tests/migrations/routers.py
@@ -0,0 +1,14 @@
+class DefaultOtherRouter:
+ def allow_migrate(self, db, app_label, model_name=None, **hints):
+ return db in {"default", "other"}
+
+
+class TestRouter:
+ def allow_migrate(self, db, app_label, model_name=None, **hints):
+ """
+ The Tribble model should be the only one to appear in the 'other' db.
+ """
+ if model_name == "tribble":
+ return db == "other"
+ elif db != "default":
+ return False
diff --git a/testbed/django__django/tests/migrations/test_add_many_to_many_field_initial/0001_initial.py b/testbed/django__django/tests/migrations/test_add_many_to_many_field_initial/0001_initial.py
new file mode 100644
index 0000000000000000000000000000000000000000..6547a71e7a4cc9669a6e83cce7dd0e2b8f9e6dc4
--- /dev/null
+++ b/testbed/django__django/tests/migrations/test_add_many_to_many_field_initial/0001_initial.py
@@ -0,0 +1,43 @@
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+ initial = True
+
+ dependencies = []
+
+ operations = [
+ migrations.CreateModel(
+ name="Project",
+ fields=[
+ (
+ "id",
+ models.AutoField(
+ auto_created=True,
+ primary_key=True,
+ serialize=False,
+ verbose_name="ID",
+ ),
+ ),
+ ],
+ ),
+ migrations.CreateModel(
+ name="Task",
+ fields=[
+ (
+ "id",
+ models.AutoField(
+ auto_created=True,
+ primary_key=True,
+ serialize=False,
+ verbose_name="ID",
+ ),
+ ),
+ ],
+ ),
+ migrations.AddField(
+ model_name="project",
+ name="tasks",
+ field=models.ManyToManyField(to="Task"),
+ ),
+ ]
diff --git a/testbed/django__django/tests/migrations/test_add_many_to_many_field_initial/0002_initial.py b/testbed/django__django/tests/migrations/test_add_many_to_many_field_initial/0002_initial.py
new file mode 100644
index 0000000000000000000000000000000000000000..2ab642d7ccedf73c9e15fd374bdfd53255c08568
--- /dev/null
+++ b/testbed/django__django/tests/migrations/test_add_many_to_many_field_initial/0002_initial.py
@@ -0,0 +1,17 @@
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+ initial = True
+
+ dependencies = [
+ ("migrations", "0001_initial"),
+ ]
+
+ operations = [
+ migrations.AddField(
+ model_name="task",
+ name="projects",
+ field=models.ManyToManyField(to="Project"),
+ ),
+ ]
diff --git a/testbed/django__django/tests/migrations/test_add_many_to_many_field_initial/__init__.py b/testbed/django__django/tests/migrations/test_add_many_to_many_field_initial/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testbed/django__django/tests/migrations/test_auto_now_add/0001_initial.py b/testbed/django__django/tests/migrations/test_auto_now_add/0001_initial.py
new file mode 100644
index 0000000000000000000000000000000000000000..cd8dff800fa6dcbc193aaa2bbefaf0754fc54925
--- /dev/null
+++ b/testbed/django__django/tests/migrations/test_auto_now_add/0001_initial.py
@@ -0,0 +1,23 @@
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+ initial = True
+
+ operations = [
+ migrations.CreateModel(
+ name="Entry",
+ fields=[
+ (
+ "id",
+ models.AutoField(
+ auto_created=True,
+ primary_key=True,
+ serialize=False,
+ verbose_name="ID",
+ ),
+ ),
+ ("title", models.CharField(max_length=255)),
+ ],
+ ),
+ ]
diff --git a/testbed/django__django/tests/migrations/test_auto_now_add/__init__.py b/testbed/django__django/tests/migrations/test_auto_now_add/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testbed/django__django/tests/migrations/test_autodetector.py b/testbed/django__django/tests/migrations/test_autodetector.py
new file mode 100644
index 0000000000000000000000000000000000000000..74892bbf3da6cb0ac74a3a84e25d9c9337d9e02a
--- /dev/null
+++ b/testbed/django__django/tests/migrations/test_autodetector.py
@@ -0,0 +1,5518 @@
+import functools
+import re
+from unittest import mock
+
+from django.apps import apps
+from django.conf import settings
+from django.contrib.auth.models import AbstractBaseUser
+from django.core.validators import RegexValidator, validate_slug
+from django.db import connection, migrations, models
+from django.db.migrations.autodetector import MigrationAutodetector
+from django.db.migrations.graph import MigrationGraph
+from django.db.migrations.loader import MigrationLoader
+from django.db.migrations.questioner import MigrationQuestioner
+from django.db.migrations.state import ModelState, ProjectState
+from django.test import SimpleTestCase, TestCase, ignore_warnings, override_settings
+from django.test.utils import isolate_lru_cache
+from django.utils.deprecation import RemovedInDjango51Warning
+
+from .models import FoodManager, FoodQuerySet
+
+
+class DeconstructibleObject:
+ """
+ A custom deconstructible object.
+ """
+
+ def __init__(self, *args, **kwargs):
+ self.args = args
+ self.kwargs = kwargs
+
+ def deconstruct(self):
+ return (self.__module__ + "." + self.__class__.__name__, self.args, self.kwargs)
+
+
+class BaseAutodetectorTests(TestCase):
+ def repr_changes(self, changes, include_dependencies=False):
+ output = ""
+ for app_label, migrations_ in sorted(changes.items()):
+ output += " %s:\n" % app_label
+ for migration in migrations_:
+ output += " %s\n" % migration.name
+ for operation in migration.operations:
+ output += " %s\n" % operation
+ if include_dependencies:
+ output += " Dependencies:\n"
+ if migration.dependencies:
+ for dep in migration.dependencies:
+ output += " %s\n" % (dep,)
+ else:
+ output += " None\n"
+ return output
+
+ def assertNumberMigrations(self, changes, app_label, number):
+ if len(changes.get(app_label, [])) != number:
+ self.fail(
+ "Incorrect number of migrations (%s) for %s (expected %s)\n%s"
+ % (
+ len(changes.get(app_label, [])),
+ app_label,
+ number,
+ self.repr_changes(changes),
+ )
+ )
+
+ def assertMigrationDependencies(self, changes, app_label, position, dependencies):
+ if not changes.get(app_label):
+ self.fail(
+ "No migrations found for %s\n%s"
+ % (app_label, self.repr_changes(changes))
+ )
+ if len(changes[app_label]) < position + 1:
+ self.fail(
+ "No migration at index %s for %s\n%s"
+ % (position, app_label, self.repr_changes(changes))
+ )
+ migration = changes[app_label][position]
+ if set(migration.dependencies) != set(dependencies):
+ self.fail(
+ "Migration dependencies mismatch for %s.%s (expected %s):\n%s"
+ % (
+ app_label,
+ migration.name,
+ dependencies,
+ self.repr_changes(changes, include_dependencies=True),
+ )
+ )
+
+ def assertOperationTypes(self, changes, app_label, position, types):
+ if not changes.get(app_label):
+ self.fail(
+ "No migrations found for %s\n%s"
+ % (app_label, self.repr_changes(changes))
+ )
+ if len(changes[app_label]) < position + 1:
+ self.fail(
+ "No migration at index %s for %s\n%s"
+ % (position, app_label, self.repr_changes(changes))
+ )
+ migration = changes[app_label][position]
+ real_types = [
+ operation.__class__.__name__ for operation in migration.operations
+ ]
+ if types != real_types:
+ self.fail(
+ "Operation type mismatch for %s.%s (expected %s):\n%s"
+ % (
+ app_label,
+ migration.name,
+ types,
+ self.repr_changes(changes),
+ )
+ )
+
+ def assertOperationAttributes(
+ self, changes, app_label, position, operation_position, **attrs
+ ):
+ if not changes.get(app_label):
+ self.fail(
+ "No migrations found for %s\n%s"
+ % (app_label, self.repr_changes(changes))
+ )
+ if len(changes[app_label]) < position + 1:
+ self.fail(
+ "No migration at index %s for %s\n%s"
+ % (position, app_label, self.repr_changes(changes))
+ )
+ migration = changes[app_label][position]
+ if len(changes[app_label]) < position + 1:
+ self.fail(
+ "No operation at index %s for %s.%s\n%s"
+ % (
+ operation_position,
+ app_label,
+ migration.name,
+ self.repr_changes(changes),
+ )
+ )
+ operation = migration.operations[operation_position]
+ for attr, value in attrs.items():
+ if getattr(operation, attr, None) != value:
+ self.fail(
+ "Attribute mismatch for %s.%s op #%s, %s (expected %r, got %r):\n%s"
+ % (
+ app_label,
+ migration.name,
+ operation_position,
+ attr,
+ value,
+ getattr(operation, attr, None),
+ self.repr_changes(changes),
+ )
+ )
+
+ def assertOperationFieldAttributes(
+ self, changes, app_label, position, operation_position, **attrs
+ ):
+ if not changes.get(app_label):
+ self.fail(
+ "No migrations found for %s\n%s"
+ % (app_label, self.repr_changes(changes))
+ )
+ if len(changes[app_label]) < position + 1:
+ self.fail(
+ "No migration at index %s for %s\n%s"
+ % (position, app_label, self.repr_changes(changes))
+ )
+ migration = changes[app_label][position]
+ if len(changes[app_label]) < position + 1:
+ self.fail(
+ "No operation at index %s for %s.%s\n%s"
+ % (
+ operation_position,
+ app_label,
+ migration.name,
+ self.repr_changes(changes),
+ )
+ )
+ operation = migration.operations[operation_position]
+ if not hasattr(operation, "field"):
+ self.fail(
+ "No field attribute for %s.%s op #%s."
+ % (
+ app_label,
+ migration.name,
+ operation_position,
+ )
+ )
+ field = operation.field
+ for attr, value in attrs.items():
+ if getattr(field, attr, None) != value:
+ self.fail(
+ "Field attribute mismatch for %s.%s op #%s, field.%s (expected %r, "
+ "got %r):\n%s"
+ % (
+ app_label,
+ migration.name,
+ operation_position,
+ attr,
+ value,
+ getattr(field, attr, None),
+ self.repr_changes(changes),
+ )
+ )
+
+ def make_project_state(self, model_states):
+ "Shortcut to make ProjectStates from lists of predefined models"
+ project_state = ProjectState()
+ for model_state in model_states:
+ project_state.add_model(model_state.clone())
+ return project_state
+
+ def get_changes(self, before_states, after_states, questioner=None):
+ if not isinstance(before_states, ProjectState):
+ before_states = self.make_project_state(before_states)
+ if not isinstance(after_states, ProjectState):
+ after_states = self.make_project_state(after_states)
+ return MigrationAutodetector(
+ before_states,
+ after_states,
+ questioner,
+ )._detect_changes()
+
+
+class AutodetectorTests(BaseAutodetectorTests):
+ """
+ Tests the migration autodetector.
+ """
+
+ author_empty = ModelState(
+ "testapp", "Author", [("id", models.AutoField(primary_key=True))]
+ )
+ author_name = ModelState(
+ "testapp",
+ "Author",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ("name", models.CharField(max_length=200)),
+ ],
+ )
+ author_name_null = ModelState(
+ "testapp",
+ "Author",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ("name", models.CharField(max_length=200, null=True)),
+ ],
+ )
+ author_name_longer = ModelState(
+ "testapp",
+ "Author",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ("name", models.CharField(max_length=400)),
+ ],
+ )
+ author_name_renamed = ModelState(
+ "testapp",
+ "Author",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ("names", models.CharField(max_length=200)),
+ ],
+ )
+ author_name_default = ModelState(
+ "testapp",
+ "Author",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ("name", models.CharField(max_length=200, default="Ada Lovelace")),
+ ],
+ )
+ author_name_db_default = ModelState(
+ "testapp",
+ "Author",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ("name", models.CharField(max_length=200, db_default="Ada Lovelace")),
+ ],
+ )
+ author_name_check_constraint = ModelState(
+ "testapp",
+ "Author",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ("name", models.CharField(max_length=200)),
+ ],
+ {
+ "constraints": [
+ models.CheckConstraint(
+ check=models.Q(name__contains="Bob"), name="name_contains_bob"
+ )
+ ]
+ },
+ )
+ author_dates_of_birth_auto_now = ModelState(
+ "testapp",
+ "Author",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ("date_of_birth", models.DateField(auto_now=True)),
+ ("date_time_of_birth", models.DateTimeField(auto_now=True)),
+ ("time_of_birth", models.TimeField(auto_now=True)),
+ ],
+ )
+ author_dates_of_birth_auto_now_add = ModelState(
+ "testapp",
+ "Author",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ("date_of_birth", models.DateField(auto_now_add=True)),
+ ("date_time_of_birth", models.DateTimeField(auto_now_add=True)),
+ ("time_of_birth", models.TimeField(auto_now_add=True)),
+ ],
+ )
+ author_name_deconstructible_1 = ModelState(
+ "testapp",
+ "Author",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ("name", models.CharField(max_length=200, default=DeconstructibleObject())),
+ ],
+ )
+ author_name_deconstructible_2 = ModelState(
+ "testapp",
+ "Author",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ("name", models.CharField(max_length=200, default=DeconstructibleObject())),
+ ],
+ )
+ author_name_deconstructible_3 = ModelState(
+ "testapp",
+ "Author",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ("name", models.CharField(max_length=200, default=models.IntegerField())),
+ ],
+ )
+ author_name_deconstructible_4 = ModelState(
+ "testapp",
+ "Author",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ("name", models.CharField(max_length=200, default=models.IntegerField())),
+ ],
+ )
+ author_name_deconstructible_list_1 = ModelState(
+ "testapp",
+ "Author",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ (
+ "name",
+ models.CharField(
+ max_length=200, default=[DeconstructibleObject(), 123]
+ ),
+ ),
+ ],
+ )
+ author_name_deconstructible_list_2 = ModelState(
+ "testapp",
+ "Author",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ (
+ "name",
+ models.CharField(
+ max_length=200, default=[DeconstructibleObject(), 123]
+ ),
+ ),
+ ],
+ )
+ author_name_deconstructible_list_3 = ModelState(
+ "testapp",
+ "Author",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ (
+ "name",
+ models.CharField(
+ max_length=200, default=[DeconstructibleObject(), 999]
+ ),
+ ),
+ ],
+ )
+ author_name_deconstructible_tuple_1 = ModelState(
+ "testapp",
+ "Author",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ (
+ "name",
+ models.CharField(
+ max_length=200, default=(DeconstructibleObject(), 123)
+ ),
+ ),
+ ],
+ )
+ author_name_deconstructible_tuple_2 = ModelState(
+ "testapp",
+ "Author",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ (
+ "name",
+ models.CharField(
+ max_length=200, default=(DeconstructibleObject(), 123)
+ ),
+ ),
+ ],
+ )
+ author_name_deconstructible_tuple_3 = ModelState(
+ "testapp",
+ "Author",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ (
+ "name",
+ models.CharField(
+ max_length=200, default=(DeconstructibleObject(), 999)
+ ),
+ ),
+ ],
+ )
+ author_name_deconstructible_dict_1 = ModelState(
+ "testapp",
+ "Author",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ (
+ "name",
+ models.CharField(
+ max_length=200,
+ default={"item": DeconstructibleObject(), "otheritem": 123},
+ ),
+ ),
+ ],
+ )
+ author_name_deconstructible_dict_2 = ModelState(
+ "testapp",
+ "Author",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ (
+ "name",
+ models.CharField(
+ max_length=200,
+ default={"item": DeconstructibleObject(), "otheritem": 123},
+ ),
+ ),
+ ],
+ )
+ author_name_deconstructible_dict_3 = ModelState(
+ "testapp",
+ "Author",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ (
+ "name",
+ models.CharField(
+ max_length=200,
+ default={"item": DeconstructibleObject(), "otheritem": 999},
+ ),
+ ),
+ ],
+ )
+ author_name_nested_deconstructible_1 = ModelState(
+ "testapp",
+ "Author",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ (
+ "name",
+ models.CharField(
+ max_length=200,
+ default=DeconstructibleObject(
+ DeconstructibleObject(1),
+ (
+ DeconstructibleObject("t1"),
+ DeconstructibleObject("t2"),
+ ),
+ a=DeconstructibleObject("A"),
+ b=DeconstructibleObject(B=DeconstructibleObject("c")),
+ ),
+ ),
+ ),
+ ],
+ )
+ author_name_nested_deconstructible_2 = ModelState(
+ "testapp",
+ "Author",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ (
+ "name",
+ models.CharField(
+ max_length=200,
+ default=DeconstructibleObject(
+ DeconstructibleObject(1),
+ (
+ DeconstructibleObject("t1"),
+ DeconstructibleObject("t2"),
+ ),
+ a=DeconstructibleObject("A"),
+ b=DeconstructibleObject(B=DeconstructibleObject("c")),
+ ),
+ ),
+ ),
+ ],
+ )
+ author_name_nested_deconstructible_changed_arg = ModelState(
+ "testapp",
+ "Author",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ (
+ "name",
+ models.CharField(
+ max_length=200,
+ default=DeconstructibleObject(
+ DeconstructibleObject(1),
+ (
+ DeconstructibleObject("t1"),
+ DeconstructibleObject("t2-changed"),
+ ),
+ a=DeconstructibleObject("A"),
+ b=DeconstructibleObject(B=DeconstructibleObject("c")),
+ ),
+ ),
+ ),
+ ],
+ )
+ author_name_nested_deconstructible_extra_arg = ModelState(
+ "testapp",
+ "Author",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ (
+ "name",
+ models.CharField(
+ max_length=200,
+ default=DeconstructibleObject(
+ DeconstructibleObject(1),
+ (
+ DeconstructibleObject("t1"),
+ DeconstructibleObject("t2"),
+ ),
+ None,
+ a=DeconstructibleObject("A"),
+ b=DeconstructibleObject(B=DeconstructibleObject("c")),
+ ),
+ ),
+ ),
+ ],
+ )
+ author_name_nested_deconstructible_changed_kwarg = ModelState(
+ "testapp",
+ "Author",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ (
+ "name",
+ models.CharField(
+ max_length=200,
+ default=DeconstructibleObject(
+ DeconstructibleObject(1),
+ (
+ DeconstructibleObject("t1"),
+ DeconstructibleObject("t2"),
+ ),
+ a=DeconstructibleObject("A"),
+ b=DeconstructibleObject(B=DeconstructibleObject("c-changed")),
+ ),
+ ),
+ ),
+ ],
+ )
+ author_name_nested_deconstructible_extra_kwarg = ModelState(
+ "testapp",
+ "Author",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ (
+ "name",
+ models.CharField(
+ max_length=200,
+ default=DeconstructibleObject(
+ DeconstructibleObject(1),
+ (
+ DeconstructibleObject("t1"),
+ DeconstructibleObject("t2"),
+ ),
+ a=DeconstructibleObject("A"),
+ b=DeconstructibleObject(B=DeconstructibleObject("c")),
+ c=None,
+ ),
+ ),
+ ),
+ ],
+ )
+ author_custom_pk = ModelState(
+ "testapp", "Author", [("pk_field", models.IntegerField(primary_key=True))]
+ )
+ author_with_biography_non_blank = ModelState(
+ "testapp",
+ "Author",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ("name", models.CharField()),
+ ("biography", models.TextField()),
+ ],
+ )
+ author_with_biography_blank = ModelState(
+ "testapp",
+ "Author",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ("name", models.CharField(blank=True)),
+ ("biography", models.TextField(blank=True)),
+ ],
+ )
+ author_with_book = ModelState(
+ "testapp",
+ "Author",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ("name", models.CharField(max_length=200)),
+ ("book", models.ForeignKey("otherapp.Book", models.CASCADE)),
+ ],
+ )
+ author_with_book_order_wrt = ModelState(
+ "testapp",
+ "Author",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ("name", models.CharField(max_length=200)),
+ ("book", models.ForeignKey("otherapp.Book", models.CASCADE)),
+ ],
+ options={"order_with_respect_to": "book"},
+ )
+ author_renamed_with_book = ModelState(
+ "testapp",
+ "Writer",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ("name", models.CharField(max_length=200)),
+ ("book", models.ForeignKey("otherapp.Book", models.CASCADE)),
+ ],
+ )
+ author_with_publisher_string = ModelState(
+ "testapp",
+ "Author",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ("name", models.CharField(max_length=200)),
+ ("publisher_name", models.CharField(max_length=200)),
+ ],
+ )
+ author_with_publisher = ModelState(
+ "testapp",
+ "Author",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ("name", models.CharField(max_length=200)),
+ ("publisher", models.ForeignKey("testapp.Publisher", models.CASCADE)),
+ ],
+ )
+ author_with_user = ModelState(
+ "testapp",
+ "Author",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ("name", models.CharField(max_length=200)),
+ ("user", models.ForeignKey("auth.User", models.CASCADE)),
+ ],
+ )
+ author_with_custom_user = ModelState(
+ "testapp",
+ "Author",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ("name", models.CharField(max_length=200)),
+ ("user", models.ForeignKey("thirdapp.CustomUser", models.CASCADE)),
+ ],
+ )
+ author_proxy = ModelState(
+ "testapp", "AuthorProxy", [], {"proxy": True}, ("testapp.author",)
+ )
+ author_proxy_options = ModelState(
+ "testapp",
+ "AuthorProxy",
+ [],
+ {
+ "proxy": True,
+ "verbose_name": "Super Author",
+ },
+ ("testapp.author",),
+ )
+ author_proxy_notproxy = ModelState(
+ "testapp", "AuthorProxy", [], {}, ("testapp.author",)
+ )
+ author_proxy_third = ModelState(
+ "thirdapp", "AuthorProxy", [], {"proxy": True}, ("testapp.author",)
+ )
+ author_proxy_third_notproxy = ModelState(
+ "thirdapp", "AuthorProxy", [], {}, ("testapp.author",)
+ )
+ author_proxy_proxy = ModelState(
+ "testapp", "AAuthorProxyProxy", [], {"proxy": True}, ("testapp.authorproxy",)
+ )
+ author_unmanaged = ModelState(
+ "testapp", "AuthorUnmanaged", [], {"managed": False}, ("testapp.author",)
+ )
+ author_unmanaged_managed = ModelState(
+ "testapp", "AuthorUnmanaged", [], {}, ("testapp.author",)
+ )
+ author_unmanaged_default_pk = ModelState(
+ "testapp", "Author", [("id", models.AutoField(primary_key=True))]
+ )
+ author_unmanaged_custom_pk = ModelState(
+ "testapp",
+ "Author",
+ [
+ ("pk_field", models.IntegerField(primary_key=True)),
+ ],
+ )
+ author_with_m2m = ModelState(
+ "testapp",
+ "Author",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ("publishers", models.ManyToManyField("testapp.Publisher")),
+ ],
+ )
+ author_with_m2m_blank = ModelState(
+ "testapp",
+ "Author",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ("publishers", models.ManyToManyField("testapp.Publisher", blank=True)),
+ ],
+ )
+ author_with_m2m_through = ModelState(
+ "testapp",
+ "Author",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ (
+ "publishers",
+ models.ManyToManyField("testapp.Publisher", through="testapp.Contract"),
+ ),
+ ],
+ )
+ author_with_renamed_m2m_through = ModelState(
+ "testapp",
+ "Author",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ (
+ "publishers",
+ models.ManyToManyField("testapp.Publisher", through="testapp.Deal"),
+ ),
+ ],
+ )
+ author_with_former_m2m = ModelState(
+ "testapp",
+ "Author",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ("publishers", models.CharField(max_length=100)),
+ ],
+ )
+ author_with_options = ModelState(
+ "testapp",
+ "Author",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ],
+ {
+ "permissions": [("can_hire", "Can hire")],
+ "verbose_name": "Authi",
+ },
+ )
+ author_with_db_table_comment = ModelState(
+ "testapp",
+ "Author",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ],
+ {"db_table_comment": "Table comment"},
+ )
+ author_with_db_table_options = ModelState(
+ "testapp",
+ "Author",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ],
+ {"db_table": "author_one"},
+ )
+ author_with_new_db_table_options = ModelState(
+ "testapp",
+ "Author",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ],
+ {"db_table": "author_two"},
+ )
+ author_renamed_with_db_table_options = ModelState(
+ "testapp",
+ "NewAuthor",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ],
+ {"db_table": "author_one"},
+ )
+ author_renamed_with_new_db_table_options = ModelState(
+ "testapp",
+ "NewAuthor",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ],
+ {"db_table": "author_three"},
+ )
+ contract = ModelState(
+ "testapp",
+ "Contract",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ("author", models.ForeignKey("testapp.Author", models.CASCADE)),
+ ("publisher", models.ForeignKey("testapp.Publisher", models.CASCADE)),
+ ],
+ )
+ contract_renamed = ModelState(
+ "testapp",
+ "Deal",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ("author", models.ForeignKey("testapp.Author", models.CASCADE)),
+ ("publisher", models.ForeignKey("testapp.Publisher", models.CASCADE)),
+ ],
+ )
+ publisher = ModelState(
+ "testapp",
+ "Publisher",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ("name", models.CharField(max_length=100)),
+ ],
+ )
+ publisher_with_author = ModelState(
+ "testapp",
+ "Publisher",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ("author", models.ForeignKey("testapp.Author", models.CASCADE)),
+ ("name", models.CharField(max_length=100)),
+ ],
+ )
+ publisher_with_aardvark_author = ModelState(
+ "testapp",
+ "Publisher",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ("author", models.ForeignKey("testapp.Aardvark", models.CASCADE)),
+ ("name", models.CharField(max_length=100)),
+ ],
+ )
+ publisher_with_book = ModelState(
+ "testapp",
+ "Publisher",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ("author", models.ForeignKey("otherapp.Book", models.CASCADE)),
+ ("name", models.CharField(max_length=100)),
+ ],
+ )
+ other_pony = ModelState(
+ "otherapp",
+ "Pony",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ],
+ )
+ other_pony_food = ModelState(
+ "otherapp",
+ "Pony",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ],
+ managers=[
+ ("food_qs", FoodQuerySet.as_manager()),
+ ("food_mgr", FoodManager("a", "b")),
+ ("food_mgr_kwargs", FoodManager("x", "y", 3, 4)),
+ ],
+ )
+ other_stable = ModelState(
+ "otherapp", "Stable", [("id", models.AutoField(primary_key=True))]
+ )
+ third_thing = ModelState(
+ "thirdapp", "Thing", [("id", models.AutoField(primary_key=True))]
+ )
+ book = ModelState(
+ "otherapp",
+ "Book",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ("author", models.ForeignKey("testapp.Author", models.CASCADE)),
+ ("title", models.CharField(max_length=200)),
+ ],
+ )
+ book_proxy_fk = ModelState(
+ "otherapp",
+ "Book",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ("author", models.ForeignKey("thirdapp.AuthorProxy", models.CASCADE)),
+ ("title", models.CharField(max_length=200)),
+ ],
+ )
+ book_proxy_proxy_fk = ModelState(
+ "otherapp",
+ "Book",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ("author", models.ForeignKey("testapp.AAuthorProxyProxy", models.CASCADE)),
+ ],
+ )
+ book_migrations_fk = ModelState(
+ "otherapp",
+ "Book",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ("author", models.ForeignKey("migrations.UnmigratedModel", models.CASCADE)),
+ ("title", models.CharField(max_length=200)),
+ ],
+ )
+ book_with_no_author_fk = ModelState(
+ "otherapp",
+ "Book",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ("author", models.IntegerField()),
+ ("title", models.CharField(max_length=200)),
+ ],
+ )
+ book_with_no_author = ModelState(
+ "otherapp",
+ "Book",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ("title", models.CharField(max_length=200)),
+ ],
+ )
+ book_with_author_renamed = ModelState(
+ "otherapp",
+ "Book",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ("author", models.ForeignKey("testapp.Writer", models.CASCADE)),
+ ("title", models.CharField(max_length=200)),
+ ],
+ )
+ book_with_field_and_author_renamed = ModelState(
+ "otherapp",
+ "Book",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ("writer", models.ForeignKey("testapp.Writer", models.CASCADE)),
+ ("title", models.CharField(max_length=200)),
+ ],
+ )
+ book_with_multiple_authors = ModelState(
+ "otherapp",
+ "Book",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ("authors", models.ManyToManyField("testapp.Author")),
+ ("title", models.CharField(max_length=200)),
+ ],
+ )
+ book_with_multiple_authors_through_attribution = ModelState(
+ "otherapp",
+ "Book",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ (
+ "authors",
+ models.ManyToManyField(
+ "testapp.Author", through="otherapp.Attribution"
+ ),
+ ),
+ ("title", models.CharField(max_length=200)),
+ ],
+ )
+ book_indexes = ModelState(
+ "otherapp",
+ "Book",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ("author", models.ForeignKey("testapp.Author", models.CASCADE)),
+ ("title", models.CharField(max_length=200)),
+ ],
+ {
+ "indexes": [
+ models.Index(fields=["author", "title"], name="book_title_author_idx")
+ ],
+ },
+ )
+ book_unordered_indexes = ModelState(
+ "otherapp",
+ "Book",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ("author", models.ForeignKey("testapp.Author", models.CASCADE)),
+ ("title", models.CharField(max_length=200)),
+ ],
+ {
+ "indexes": [
+ models.Index(fields=["title", "author"], name="book_author_title_idx")
+ ],
+ },
+ )
+ book_unique_together = ModelState(
+ "otherapp",
+ "Book",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ("author", models.ForeignKey("testapp.Author", models.CASCADE)),
+ ("title", models.CharField(max_length=200)),
+ ],
+ {
+ "unique_together": {("author", "title")},
+ },
+ )
+ book_unique_together_2 = ModelState(
+ "otherapp",
+ "Book",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ("author", models.ForeignKey("testapp.Author", models.CASCADE)),
+ ("title", models.CharField(max_length=200)),
+ ],
+ {
+ "unique_together": {("title", "author")},
+ },
+ )
+ book_unique_together_3 = ModelState(
+ "otherapp",
+ "Book",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ("newfield", models.IntegerField()),
+ ("author", models.ForeignKey("testapp.Author", models.CASCADE)),
+ ("title", models.CharField(max_length=200)),
+ ],
+ {
+ "unique_together": {("title", "newfield")},
+ },
+ )
+ book_unique_together_4 = ModelState(
+ "otherapp",
+ "Book",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ("newfield2", models.IntegerField()),
+ ("author", models.ForeignKey("testapp.Author", models.CASCADE)),
+ ("title", models.CharField(max_length=200)),
+ ],
+ {
+ "unique_together": {("title", "newfield2")},
+ },
+ )
+ attribution = ModelState(
+ "otherapp",
+ "Attribution",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ("author", models.ForeignKey("testapp.Author", models.CASCADE)),
+ ("book", models.ForeignKey("otherapp.Book", models.CASCADE)),
+ ],
+ )
+ edition = ModelState(
+ "thirdapp",
+ "Edition",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ("book", models.ForeignKey("otherapp.Book", models.CASCADE)),
+ ],
+ )
+ custom_user = ModelState(
+ "thirdapp",
+ "CustomUser",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ("username", models.CharField(max_length=255)),
+ ],
+ bases=(AbstractBaseUser,),
+ )
+ custom_user_no_inherit = ModelState(
+ "thirdapp",
+ "CustomUser",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ("username", models.CharField(max_length=255)),
+ ],
+ )
+ aardvark = ModelState(
+ "thirdapp", "Aardvark", [("id", models.AutoField(primary_key=True))]
+ )
+ aardvark_testapp = ModelState(
+ "testapp", "Aardvark", [("id", models.AutoField(primary_key=True))]
+ )
+ aardvark_based_on_author = ModelState(
+ "testapp", "Aardvark", [], bases=("testapp.Author",)
+ )
+ aardvark_pk_fk_author = ModelState(
+ "testapp",
+ "Aardvark",
+ [
+ (
+ "id",
+ models.OneToOneField(
+ "testapp.Author", models.CASCADE, primary_key=True
+ ),
+ ),
+ ],
+ )
+ knight = ModelState("eggs", "Knight", [("id", models.AutoField(primary_key=True))])
+ rabbit = ModelState(
+ "eggs",
+ "Rabbit",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ("knight", models.ForeignKey("eggs.Knight", models.CASCADE)),
+ ("parent", models.ForeignKey("eggs.Rabbit", models.CASCADE)),
+ ],
+ {
+ "unique_together": {("parent", "knight")},
+ "indexes": [
+ models.Index(
+ fields=["parent", "knight"], name="rabbit_circular_fk_index"
+ )
+ ],
+ },
+ )
+
+ def test_arrange_for_graph(self):
+ """Tests auto-naming of migrations for graph matching."""
+ # Make a fake graph
+ graph = MigrationGraph()
+ graph.add_node(("testapp", "0001_initial"), None)
+ graph.add_node(("testapp", "0002_foobar"), None)
+ graph.add_node(("otherapp", "0001_initial"), None)
+ graph.add_dependency(
+ "testapp.0002_foobar",
+ ("testapp", "0002_foobar"),
+ ("testapp", "0001_initial"),
+ )
+ graph.add_dependency(
+ "testapp.0002_foobar",
+ ("testapp", "0002_foobar"),
+ ("otherapp", "0001_initial"),
+ )
+ # Use project state to make a new migration change set
+ before = self.make_project_state([self.publisher, self.other_pony])
+ after = self.make_project_state(
+ [
+ self.author_empty,
+ self.publisher,
+ self.other_pony,
+ self.other_stable,
+ ]
+ )
+ autodetector = MigrationAutodetector(before, after)
+ changes = autodetector._detect_changes()
+ # Run through arrange_for_graph
+ changes = autodetector.arrange_for_graph(changes, graph)
+ # Make sure there's a new name, deps match, etc.
+ self.assertEqual(changes["testapp"][0].name, "0003_author")
+ self.assertEqual(
+ changes["testapp"][0].dependencies, [("testapp", "0002_foobar")]
+ )
+ self.assertEqual(changes["otherapp"][0].name, "0002_stable")
+ self.assertEqual(
+ changes["otherapp"][0].dependencies, [("otherapp", "0001_initial")]
+ )
+
+ def test_arrange_for_graph_with_multiple_initial(self):
+ # Make a fake graph.
+ graph = MigrationGraph()
+ # Use project state to make a new migration change set.
+ before = self.make_project_state([])
+ after = self.make_project_state(
+ [self.author_with_book, self.book, self.attribution]
+ )
+ autodetector = MigrationAutodetector(
+ before, after, MigrationQuestioner({"ask_initial": True})
+ )
+ changes = autodetector._detect_changes()
+ changes = autodetector.arrange_for_graph(changes, graph)
+
+ self.assertEqual(changes["otherapp"][0].name, "0001_initial")
+ self.assertEqual(changes["otherapp"][0].dependencies, [])
+ self.assertEqual(changes["otherapp"][1].name, "0002_initial")
+ self.assertCountEqual(
+ changes["otherapp"][1].dependencies,
+ [("testapp", "0001_initial"), ("otherapp", "0001_initial")],
+ )
+ self.assertEqual(changes["testapp"][0].name, "0001_initial")
+ self.assertEqual(
+ changes["testapp"][0].dependencies, [("otherapp", "0001_initial")]
+ )
+
+ def test_trim_apps(self):
+ """
+ Trim does not remove dependencies but does remove unwanted apps.
+ """
+ # Use project state to make a new migration change set
+ before = self.make_project_state([])
+ after = self.make_project_state(
+ [self.author_empty, self.other_pony, self.other_stable, self.third_thing]
+ )
+ autodetector = MigrationAutodetector(
+ before, after, MigrationQuestioner({"ask_initial": True})
+ )
+ changes = autodetector._detect_changes()
+ # Run through arrange_for_graph
+ graph = MigrationGraph()
+ changes = autodetector.arrange_for_graph(changes, graph)
+ changes["testapp"][0].dependencies.append(("otherapp", "0001_initial"))
+ changes = autodetector._trim_to_apps(changes, {"testapp"})
+ # Make sure there's the right set of migrations
+ self.assertEqual(changes["testapp"][0].name, "0001_initial")
+ self.assertEqual(changes["otherapp"][0].name, "0001_initial")
+ self.assertNotIn("thirdapp", changes)
+
+ def test_custom_migration_name(self):
+ """Tests custom naming of migrations for graph matching."""
+ # Make a fake graph
+ graph = MigrationGraph()
+ graph.add_node(("testapp", "0001_initial"), None)
+ graph.add_node(("testapp", "0002_foobar"), None)
+ graph.add_node(("otherapp", "0001_initial"), None)
+ graph.add_dependency(
+ "testapp.0002_foobar",
+ ("testapp", "0002_foobar"),
+ ("testapp", "0001_initial"),
+ )
+
+ # Use project state to make a new migration change set
+ before = self.make_project_state([])
+ after = self.make_project_state(
+ [self.author_empty, self.other_pony, self.other_stable]
+ )
+ autodetector = MigrationAutodetector(before, after)
+ changes = autodetector._detect_changes()
+
+ # Run through arrange_for_graph
+ migration_name = "custom_name"
+ changes = autodetector.arrange_for_graph(changes, graph, migration_name)
+
+ # Make sure there's a new name, deps match, etc.
+ self.assertEqual(changes["testapp"][0].name, "0003_%s" % migration_name)
+ self.assertEqual(
+ changes["testapp"][0].dependencies, [("testapp", "0002_foobar")]
+ )
+ self.assertEqual(changes["otherapp"][0].name, "0002_%s" % migration_name)
+ self.assertEqual(
+ changes["otherapp"][0].dependencies, [("otherapp", "0001_initial")]
+ )
+
+ def test_new_model(self):
+ """Tests autodetection of new models."""
+ changes = self.get_changes([], [self.other_pony_food])
+ # Right number/type of migrations?
+ self.assertNumberMigrations(changes, "otherapp", 1)
+ self.assertOperationTypes(changes, "otherapp", 0, ["CreateModel"])
+ self.assertOperationAttributes(changes, "otherapp", 0, 0, name="Pony")
+ self.assertEqual(
+ [name for name, mgr in changes["otherapp"][0].operations[0].managers],
+ ["food_qs", "food_mgr", "food_mgr_kwargs"],
+ )
+
+ def test_old_model(self):
+ """Tests deletion of old models."""
+ changes = self.get_changes([self.author_empty], [])
+ # Right number/type of migrations?
+ self.assertNumberMigrations(changes, "testapp", 1)
+ self.assertOperationTypes(changes, "testapp", 0, ["DeleteModel"])
+ self.assertOperationAttributes(changes, "testapp", 0, 0, name="Author")
+
+ def test_add_field(self):
+ """Tests autodetection of new fields."""
+ changes = self.get_changes([self.author_empty], [self.author_name])
+ # Right number/type of migrations?
+ self.assertNumberMigrations(changes, "testapp", 1)
+ self.assertOperationTypes(changes, "testapp", 0, ["AddField"])
+ self.assertOperationAttributes(changes, "testapp", 0, 0, name="name")
+
+ @mock.patch(
+ "django.db.migrations.questioner.MigrationQuestioner.ask_not_null_addition",
+ side_effect=AssertionError("Should not have prompted for not null addition"),
+ )
+ def test_add_not_null_field_with_db_default(self, mocked_ask_method):
+ changes = self.get_changes([self.author_empty], [self.author_name_db_default])
+ self.assertNumberMigrations(changes, "testapp", 1)
+ self.assertOperationTypes(changes, "testapp", 0, ["AddField"])
+ self.assertOperationAttributes(
+ changes, "testapp", 0, 0, name="name", preserve_default=True
+ )
+ self.assertOperationFieldAttributes(
+ changes, "testapp", 0, 0, db_default=models.Value("Ada Lovelace")
+ )
+
+ @mock.patch(
+ "django.db.migrations.questioner.MigrationQuestioner.ask_not_null_addition",
+ side_effect=AssertionError("Should not have prompted for not null addition"),
+ )
+ def test_add_date_fields_with_auto_now_not_asking_for_default(
+ self, mocked_ask_method
+ ):
+ changes = self.get_changes(
+ [self.author_empty], [self.author_dates_of_birth_auto_now]
+ )
+ # Right number/type of migrations?
+ self.assertNumberMigrations(changes, "testapp", 1)
+ self.assertOperationTypes(
+ changes, "testapp", 0, ["AddField", "AddField", "AddField"]
+ )
+ self.assertOperationFieldAttributes(changes, "testapp", 0, 0, auto_now=True)
+ self.assertOperationFieldAttributes(changes, "testapp", 0, 1, auto_now=True)
+ self.assertOperationFieldAttributes(changes, "testapp", 0, 2, auto_now=True)
+
+ @mock.patch(
+ "django.db.migrations.questioner.MigrationQuestioner.ask_not_null_addition",
+ side_effect=AssertionError("Should not have prompted for not null addition"),
+ )
+ def test_add_date_fields_with_auto_now_add_not_asking_for_null_addition(
+ self, mocked_ask_method
+ ):
+ changes = self.get_changes(
+ [self.author_empty], [self.author_dates_of_birth_auto_now_add]
+ )
+ # Right number/type of migrations?
+ self.assertNumberMigrations(changes, "testapp", 1)
+ self.assertOperationTypes(
+ changes, "testapp", 0, ["AddField", "AddField", "AddField"]
+ )
+ self.assertOperationFieldAttributes(changes, "testapp", 0, 0, auto_now_add=True)
+ self.assertOperationFieldAttributes(changes, "testapp", 0, 1, auto_now_add=True)
+ self.assertOperationFieldAttributes(changes, "testapp", 0, 2, auto_now_add=True)
+
+ @mock.patch(
+ "django.db.migrations.questioner.MigrationQuestioner.ask_auto_now_add_addition"
+ )
+ def test_add_date_fields_with_auto_now_add_asking_for_default(
+ self, mocked_ask_method
+ ):
+ changes = self.get_changes(
+ [self.author_empty], [self.author_dates_of_birth_auto_now_add]
+ )
+ # Right number/type of migrations?
+ self.assertNumberMigrations(changes, "testapp", 1)
+ self.assertOperationTypes(
+ changes, "testapp", 0, ["AddField", "AddField", "AddField"]
+ )
+ self.assertOperationFieldAttributes(changes, "testapp", 0, 0, auto_now_add=True)
+ self.assertOperationFieldAttributes(changes, "testapp", 0, 1, auto_now_add=True)
+ self.assertOperationFieldAttributes(changes, "testapp", 0, 2, auto_now_add=True)
+ self.assertEqual(mocked_ask_method.call_count, 3)
+
+ def test_remove_field(self):
+ """Tests autodetection of removed fields."""
+ changes = self.get_changes([self.author_name], [self.author_empty])
+ # Right number/type of migrations?
+ self.assertNumberMigrations(changes, "testapp", 1)
+ self.assertOperationTypes(changes, "testapp", 0, ["RemoveField"])
+ self.assertOperationAttributes(changes, "testapp", 0, 0, name="name")
+
+ def test_alter_field(self):
+ """Tests autodetection of new fields."""
+ changes = self.get_changes([self.author_name], [self.author_name_longer])
+ # Right number/type of migrations?
+ self.assertNumberMigrations(changes, "testapp", 1)
+ self.assertOperationTypes(changes, "testapp", 0, ["AlterField"])
+ self.assertOperationAttributes(
+ changes, "testapp", 0, 0, name="name", preserve_default=True
+ )
+
+ def test_supports_functools_partial(self):
+ def _content_file_name(instance, filename, key, **kwargs):
+ return "{}/{}".format(instance, filename)
+
+ def content_file_name(key, **kwargs):
+ return functools.partial(_content_file_name, key, **kwargs)
+
+ # An unchanged partial reference.
+ before = [
+ ModelState(
+ "testapp",
+ "Author",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ (
+ "file",
+ models.FileField(
+ max_length=200, upload_to=content_file_name("file")
+ ),
+ ),
+ ],
+ )
+ ]
+ after = [
+ ModelState(
+ "testapp",
+ "Author",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ (
+ "file",
+ models.FileField(
+ max_length=200, upload_to=content_file_name("file")
+ ),
+ ),
+ ],
+ )
+ ]
+ changes = self.get_changes(before, after)
+ self.assertNumberMigrations(changes, "testapp", 0)
+
+ # A changed partial reference.
+ args_changed = [
+ ModelState(
+ "testapp",
+ "Author",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ (
+ "file",
+ models.FileField(
+ max_length=200, upload_to=content_file_name("other-file")
+ ),
+ ),
+ ],
+ )
+ ]
+ changes = self.get_changes(before, args_changed)
+ self.assertNumberMigrations(changes, "testapp", 1)
+ self.assertOperationTypes(changes, "testapp", 0, ["AlterField"])
+ # Can't use assertOperationFieldAttributes because we need the
+ # deconstructed version, i.e., the exploded func/args/keywords rather
+ # than the partial: we don't care if it's not the same instance of the
+ # partial, only if it's the same source function, args, and keywords.
+ value = changes["testapp"][0].operations[0].field.upload_to
+ self.assertEqual(
+ (_content_file_name, ("other-file",), {}),
+ (value.func, value.args, value.keywords),
+ )
+
+ kwargs_changed = [
+ ModelState(
+ "testapp",
+ "Author",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ (
+ "file",
+ models.FileField(
+ max_length=200,
+ upload_to=content_file_name("file", spam="eggs"),
+ ),
+ ),
+ ],
+ )
+ ]
+ changes = self.get_changes(before, kwargs_changed)
+ self.assertNumberMigrations(changes, "testapp", 1)
+ self.assertOperationTypes(changes, "testapp", 0, ["AlterField"])
+ value = changes["testapp"][0].operations[0].field.upload_to
+ self.assertEqual(
+ (_content_file_name, ("file",), {"spam": "eggs"}),
+ (value.func, value.args, value.keywords),
+ )
+
+ @mock.patch(
+ "django.db.migrations.questioner.MigrationQuestioner.ask_not_null_alteration",
+ side_effect=AssertionError("Should not have prompted for not null addition"),
+ )
+ def test_alter_field_to_not_null_with_default(self, mocked_ask_method):
+ """
+ #23609 - Tests autodetection of nullable to non-nullable alterations.
+ """
+ changes = self.get_changes([self.author_name_null], [self.author_name_default])
+ # Right number/type of migrations?
+ self.assertNumberMigrations(changes, "testapp", 1)
+ self.assertOperationTypes(changes, "testapp", 0, ["AlterField"])
+ self.assertOperationAttributes(
+ changes, "testapp", 0, 0, name="name", preserve_default=True
+ )
+ self.assertOperationFieldAttributes(
+ changes, "testapp", 0, 0, default="Ada Lovelace"
+ )
+
+ @mock.patch(
+ "django.db.migrations.questioner.MigrationQuestioner.ask_not_null_alteration",
+ side_effect=AssertionError("Should not have prompted for not null alteration"),
+ )
+ def test_alter_field_to_not_null_with_db_default(self, mocked_ask_method):
+ changes = self.get_changes(
+ [self.author_name_null], [self.author_name_db_default]
+ )
+ self.assertNumberMigrations(changes, "testapp", 1)
+ self.assertOperationTypes(changes, "testapp", 0, ["AlterField"])
+ self.assertOperationAttributes(
+ changes, "testapp", 0, 0, name="name", preserve_default=True
+ )
+ self.assertOperationFieldAttributes(
+ changes, "testapp", 0, 0, db_default=models.Value("Ada Lovelace")
+ )
+
+ @mock.patch(
+ "django.db.migrations.questioner.MigrationQuestioner.ask_not_null_alteration",
+ return_value=models.NOT_PROVIDED,
+ )
+ def test_alter_field_to_not_null_without_default(self, mocked_ask_method):
+ """
+ #23609 - Tests autodetection of nullable to non-nullable alterations.
+ """
+ changes = self.get_changes([self.author_name_null], [self.author_name])
+ self.assertEqual(mocked_ask_method.call_count, 1)
+ # Right number/type of migrations?
+ self.assertNumberMigrations(changes, "testapp", 1)
+ self.assertOperationTypes(changes, "testapp", 0, ["AlterField"])
+ self.assertOperationAttributes(
+ changes, "testapp", 0, 0, name="name", preserve_default=True
+ )
+ self.assertOperationFieldAttributes(
+ changes, "testapp", 0, 0, default=models.NOT_PROVIDED
+ )
+
+ @mock.patch(
+ "django.db.migrations.questioner.MigrationQuestioner.ask_not_null_alteration",
+ return_value="Some Name",
+ )
+ def test_alter_field_to_not_null_oneoff_default(self, mocked_ask_method):
+ """
+ #23609 - Tests autodetection of nullable to non-nullable alterations.
+ """
+ changes = self.get_changes([self.author_name_null], [self.author_name])
+ self.assertEqual(mocked_ask_method.call_count, 1)
+ # Right number/type of migrations?
+ self.assertNumberMigrations(changes, "testapp", 1)
+ self.assertOperationTypes(changes, "testapp", 0, ["AlterField"])
+ self.assertOperationAttributes(
+ changes, "testapp", 0, 0, name="name", preserve_default=False
+ )
+ self.assertOperationFieldAttributes(
+ changes, "testapp", 0, 0, default="Some Name"
+ )
+
+ def test_rename_field(self):
+ """Tests autodetection of renamed fields."""
+ changes = self.get_changes(
+ [self.author_name],
+ [self.author_name_renamed],
+ MigrationQuestioner({"ask_rename": True}),
+ )
+ # Right number/type of migrations?
+ self.assertNumberMigrations(changes, "testapp", 1)
+ self.assertOperationTypes(changes, "testapp", 0, ["RenameField"])
+ self.assertOperationAttributes(
+ changes, "testapp", 0, 0, old_name="name", new_name="names"
+ )
+
+ def test_rename_field_foreign_key_to_field(self):
+ before = [
+ ModelState(
+ "app",
+ "Foo",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ("field", models.IntegerField(unique=True)),
+ ],
+ ),
+ ModelState(
+ "app",
+ "Bar",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ (
+ "foo",
+ models.ForeignKey("app.Foo", models.CASCADE, to_field="field"),
+ ),
+ ],
+ ),
+ ]
+ after = [
+ ModelState(
+ "app",
+ "Foo",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ("renamed_field", models.IntegerField(unique=True)),
+ ],
+ ),
+ ModelState(
+ "app",
+ "Bar",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ (
+ "foo",
+ models.ForeignKey(
+ "app.Foo", models.CASCADE, to_field="renamed_field"
+ ),
+ ),
+ ],
+ ),
+ ]
+ changes = self.get_changes(
+ before, after, MigrationQuestioner({"ask_rename": True})
+ )
+ # Right number/type of migrations?
+ self.assertNumberMigrations(changes, "app", 1)
+ self.assertOperationTypes(changes, "app", 0, ["RenameField"])
+ self.assertOperationAttributes(
+ changes, "app", 0, 0, old_name="field", new_name="renamed_field"
+ )
+
+ def test_rename_foreign_object_fields(self):
+ fields = ("first", "second")
+ renamed_fields = ("first_renamed", "second_renamed")
+ before = [
+ ModelState(
+ "app",
+ "Foo",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ("first", models.IntegerField()),
+ ("second", models.IntegerField()),
+ ],
+ options={"unique_together": {fields}},
+ ),
+ ModelState(
+ "app",
+ "Bar",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ("first", models.IntegerField()),
+ ("second", models.IntegerField()),
+ (
+ "foo",
+ models.ForeignObject(
+ "app.Foo",
+ models.CASCADE,
+ from_fields=fields,
+ to_fields=fields,
+ ),
+ ),
+ ],
+ ),
+ ]
+ # Case 1: to_fields renames.
+ after = [
+ ModelState(
+ "app",
+ "Foo",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ("first_renamed", models.IntegerField()),
+ ("second_renamed", models.IntegerField()),
+ ],
+ options={"unique_together": {renamed_fields}},
+ ),
+ ModelState(
+ "app",
+ "Bar",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ("first", models.IntegerField()),
+ ("second", models.IntegerField()),
+ (
+ "foo",
+ models.ForeignObject(
+ "app.Foo",
+ models.CASCADE,
+ from_fields=fields,
+ to_fields=renamed_fields,
+ ),
+ ),
+ ],
+ ),
+ ]
+ changes = self.get_changes(
+ before, after, MigrationQuestioner({"ask_rename": True})
+ )
+ self.assertNumberMigrations(changes, "app", 1)
+ self.assertOperationTypes(
+ changes, "app", 0, ["RenameField", "RenameField", "AlterUniqueTogether"]
+ )
+ self.assertOperationAttributes(
+ changes,
+ "app",
+ 0,
+ 0,
+ model_name="foo",
+ old_name="first",
+ new_name="first_renamed",
+ )
+ self.assertOperationAttributes(
+ changes,
+ "app",
+ 0,
+ 1,
+ model_name="foo",
+ old_name="second",
+ new_name="second_renamed",
+ )
+ # Case 2: from_fields renames.
+ after = [
+ ModelState(
+ "app",
+ "Foo",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ("first", models.IntegerField()),
+ ("second", models.IntegerField()),
+ ],
+ options={"unique_together": {fields}},
+ ),
+ ModelState(
+ "app",
+ "Bar",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ("first_renamed", models.IntegerField()),
+ ("second_renamed", models.IntegerField()),
+ (
+ "foo",
+ models.ForeignObject(
+ "app.Foo",
+ models.CASCADE,
+ from_fields=renamed_fields,
+ to_fields=fields,
+ ),
+ ),
+ ],
+ ),
+ ]
+ changes = self.get_changes(
+ before, after, MigrationQuestioner({"ask_rename": True})
+ )
+ self.assertNumberMigrations(changes, "app", 1)
+ self.assertOperationTypes(changes, "app", 0, ["RenameField", "RenameField"])
+ self.assertOperationAttributes(
+ changes,
+ "app",
+ 0,
+ 0,
+ model_name="bar",
+ old_name="first",
+ new_name="first_renamed",
+ )
+ self.assertOperationAttributes(
+ changes,
+ "app",
+ 0,
+ 1,
+ model_name="bar",
+ old_name="second",
+ new_name="second_renamed",
+ )
+
+ def test_rename_referenced_primary_key(self):
+ before = [
+ ModelState(
+ "app",
+ "Foo",
+ [
+ ("id", models.CharField(primary_key=True, serialize=False)),
+ ],
+ ),
+ ModelState(
+ "app",
+ "Bar",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ("foo", models.ForeignKey("app.Foo", models.CASCADE)),
+ ],
+ ),
+ ]
+ after = [
+ ModelState(
+ "app",
+ "Foo",
+ [("renamed_id", models.CharField(primary_key=True, serialize=False))],
+ ),
+ ModelState(
+ "app",
+ "Bar",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ("foo", models.ForeignKey("app.Foo", models.CASCADE)),
+ ],
+ ),
+ ]
+ changes = self.get_changes(
+ before, after, MigrationQuestioner({"ask_rename": True})
+ )
+ self.assertNumberMigrations(changes, "app", 1)
+ self.assertOperationTypes(changes, "app", 0, ["RenameField"])
+ self.assertOperationAttributes(
+ changes, "app", 0, 0, old_name="id", new_name="renamed_id"
+ )
+
+ def test_rename_field_preserved_db_column(self):
+ """
+ RenameField is used if a field is renamed and db_column equal to the
+ old field's column is added.
+ """
+ before = [
+ ModelState(
+ "app",
+ "Foo",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ("field", models.IntegerField()),
+ ],
+ ),
+ ]
+ after = [
+ ModelState(
+ "app",
+ "Foo",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ("renamed_field", models.IntegerField(db_column="field")),
+ ],
+ ),
+ ]
+ changes = self.get_changes(
+ before, after, MigrationQuestioner({"ask_rename": True})
+ )
+ self.assertNumberMigrations(changes, "app", 1)
+ self.assertOperationTypes(changes, "app", 0, ["AlterField", "RenameField"])
+ self.assertOperationAttributes(
+ changes,
+ "app",
+ 0,
+ 0,
+ model_name="foo",
+ name="field",
+ )
+ self.assertEqual(
+ changes["app"][0].operations[0].field.deconstruct(),
+ (
+ "field",
+ "django.db.models.IntegerField",
+ [],
+ {"db_column": "field"},
+ ),
+ )
+ self.assertOperationAttributes(
+ changes,
+ "app",
+ 0,
+ 1,
+ model_name="foo",
+ old_name="field",
+ new_name="renamed_field",
+ )
+
+ def test_rename_related_field_preserved_db_column(self):
+ before = [
+ ModelState(
+ "app",
+ "Foo",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ],
+ ),
+ ModelState(
+ "app",
+ "Bar",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ("foo", models.ForeignKey("app.Foo", models.CASCADE)),
+ ],
+ ),
+ ]
+ after = [
+ ModelState(
+ "app",
+ "Foo",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ],
+ ),
+ ModelState(
+ "app",
+ "Bar",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ (
+ "renamed_foo",
+ models.ForeignKey(
+ "app.Foo", models.CASCADE, db_column="foo_id"
+ ),
+ ),
+ ],
+ ),
+ ]
+ changes = self.get_changes(
+ before, after, MigrationQuestioner({"ask_rename": True})
+ )
+ self.assertNumberMigrations(changes, "app", 1)
+ self.assertOperationTypes(changes, "app", 0, ["AlterField", "RenameField"])
+ self.assertOperationAttributes(
+ changes,
+ "app",
+ 0,
+ 0,
+ model_name="bar",
+ name="foo",
+ )
+ self.assertEqual(
+ changes["app"][0].operations[0].field.deconstruct(),
+ (
+ "foo",
+ "django.db.models.ForeignKey",
+ [],
+ {"to": "app.foo", "on_delete": models.CASCADE, "db_column": "foo_id"},
+ ),
+ )
+ self.assertOperationAttributes(
+ changes,
+ "app",
+ 0,
+ 1,
+ model_name="bar",
+ old_name="foo",
+ new_name="renamed_foo",
+ )
+
+ def test_rename_field_with_renamed_model(self):
+ changes = self.get_changes(
+ [self.author_name],
+ [
+ ModelState(
+ "testapp",
+ "RenamedAuthor",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ("renamed_name", models.CharField(max_length=200)),
+ ],
+ ),
+ ],
+ MigrationQuestioner({"ask_rename_model": True, "ask_rename": True}),
+ )
+ self.assertNumberMigrations(changes, "testapp", 1)
+ self.assertOperationTypes(changes, "testapp", 0, ["RenameModel", "RenameField"])
+ self.assertOperationAttributes(
+ changes,
+ "testapp",
+ 0,
+ 0,
+ old_name="Author",
+ new_name="RenamedAuthor",
+ )
+ self.assertOperationAttributes(
+ changes,
+ "testapp",
+ 0,
+ 1,
+ old_name="name",
+ new_name="renamed_name",
+ )
+
+ def test_rename_model(self):
+ """Tests autodetection of renamed models."""
+ changes = self.get_changes(
+ [self.author_with_book, self.book],
+ [self.author_renamed_with_book, self.book_with_author_renamed],
+ MigrationQuestioner({"ask_rename_model": True}),
+ )
+ # Right number/type of migrations?
+ self.assertNumberMigrations(changes, "testapp", 1)
+ self.assertOperationTypes(changes, "testapp", 0, ["RenameModel"])
+ self.assertOperationAttributes(
+ changes, "testapp", 0, 0, old_name="Author", new_name="Writer"
+ )
+ # Now that RenameModel handles related fields too, there should be
+ # no AlterField for the related field.
+ self.assertNumberMigrations(changes, "otherapp", 0)
+
+ def test_rename_model_case(self):
+ """
+ Model name is case-insensitive. Changing case doesn't lead to any
+ autodetected operations.
+ """
+ author_renamed = ModelState(
+ "testapp",
+ "author",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ],
+ )
+ changes = self.get_changes(
+ [self.author_empty, self.book],
+ [author_renamed, self.book],
+ questioner=MigrationQuestioner({"ask_rename_model": True}),
+ )
+ self.assertNumberMigrations(changes, "testapp", 0)
+ self.assertNumberMigrations(changes, "otherapp", 0)
+
+ def test_renamed_referenced_m2m_model_case(self):
+ publisher_renamed = ModelState(
+ "testapp",
+ "publisher",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ("name", models.CharField(max_length=100)),
+ ],
+ )
+ changes = self.get_changes(
+ [self.publisher, self.author_with_m2m],
+ [publisher_renamed, self.author_with_m2m],
+ questioner=MigrationQuestioner({"ask_rename_model": True}),
+ )
+ self.assertNumberMigrations(changes, "testapp", 0)
+ self.assertNumberMigrations(changes, "otherapp", 0)
+
+ def test_rename_m2m_through_model(self):
+ """
+ Tests autodetection of renamed models that are used in M2M relations as
+ through models.
+ """
+ changes = self.get_changes(
+ [self.author_with_m2m_through, self.publisher, self.contract],
+ [
+ self.author_with_renamed_m2m_through,
+ self.publisher,
+ self.contract_renamed,
+ ],
+ MigrationQuestioner({"ask_rename_model": True}),
+ )
+ # Right number/type of migrations?
+ self.assertNumberMigrations(changes, "testapp", 1)
+ self.assertOperationTypes(changes, "testapp", 0, ["RenameModel"])
+ self.assertOperationAttributes(
+ changes, "testapp", 0, 0, old_name="Contract", new_name="Deal"
+ )
+
+ def test_rename_model_with_renamed_rel_field(self):
+ """
+ Tests autodetection of renamed models while simultaneously renaming one
+ of the fields that relate to the renamed model.
+ """
+ changes = self.get_changes(
+ [self.author_with_book, self.book],
+ [self.author_renamed_with_book, self.book_with_field_and_author_renamed],
+ MigrationQuestioner({"ask_rename": True, "ask_rename_model": True}),
+ )
+ # Right number/type of migrations?
+ self.assertNumberMigrations(changes, "testapp", 1)
+ self.assertOperationTypes(changes, "testapp", 0, ["RenameModel"])
+ self.assertOperationAttributes(
+ changes, "testapp", 0, 0, old_name="Author", new_name="Writer"
+ )
+ # Right number/type of migrations for related field rename?
+ # Alter is already taken care of.
+ self.assertNumberMigrations(changes, "otherapp", 1)
+ self.assertOperationTypes(changes, "otherapp", 0, ["RenameField"])
+ self.assertOperationAttributes(
+ changes, "otherapp", 0, 0, old_name="author", new_name="writer"
+ )
+
+ def test_rename_model_with_fks_in_different_position(self):
+ """
+ #24537 - The order of fields in a model does not influence
+ the RenameModel detection.
+ """
+ before = [
+ ModelState(
+ "testapp",
+ "EntityA",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ],
+ ),
+ ModelState(
+ "testapp",
+ "EntityB",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ("some_label", models.CharField(max_length=255)),
+ ("entity_a", models.ForeignKey("testapp.EntityA", models.CASCADE)),
+ ],
+ ),
+ ]
+ after = [
+ ModelState(
+ "testapp",
+ "EntityA",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ],
+ ),
+ ModelState(
+ "testapp",
+ "RenamedEntityB",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ("entity_a", models.ForeignKey("testapp.EntityA", models.CASCADE)),
+ ("some_label", models.CharField(max_length=255)),
+ ],
+ ),
+ ]
+ changes = self.get_changes(
+ before, after, MigrationQuestioner({"ask_rename_model": True})
+ )
+ self.assertNumberMigrations(changes, "testapp", 1)
+ self.assertOperationTypes(changes, "testapp", 0, ["RenameModel"])
+ self.assertOperationAttributes(
+ changes, "testapp", 0, 0, old_name="EntityB", new_name="RenamedEntityB"
+ )
+
+ def test_rename_model_reverse_relation_dependencies(self):
+ """
+ The migration to rename a model pointed to by a foreign key in another
+ app must run after the other app's migration that adds the foreign key
+ with model's original name. Therefore, the renaming migration has a
+ dependency on that other migration.
+ """
+ before = [
+ ModelState(
+ "testapp",
+ "EntityA",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ],
+ ),
+ ModelState(
+ "otherapp",
+ "EntityB",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ("entity_a", models.ForeignKey("testapp.EntityA", models.CASCADE)),
+ ],
+ ),
+ ]
+ after = [
+ ModelState(
+ "testapp",
+ "RenamedEntityA",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ],
+ ),
+ ModelState(
+ "otherapp",
+ "EntityB",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ (
+ "entity_a",
+ models.ForeignKey("testapp.RenamedEntityA", models.CASCADE),
+ ),
+ ],
+ ),
+ ]
+ changes = self.get_changes(
+ before, after, MigrationQuestioner({"ask_rename_model": True})
+ )
+ self.assertNumberMigrations(changes, "testapp", 1)
+ self.assertMigrationDependencies(
+ changes, "testapp", 0, [("otherapp", "__first__")]
+ )
+ self.assertOperationTypes(changes, "testapp", 0, ["RenameModel"])
+ self.assertOperationAttributes(
+ changes, "testapp", 0, 0, old_name="EntityA", new_name="RenamedEntityA"
+ )
+
+ def test_fk_dependency(self):
+ """Having a ForeignKey automatically adds a dependency."""
+ # Note that testapp (author) has no dependencies,
+ # otherapp (book) depends on testapp (author),
+ # thirdapp (edition) depends on otherapp (book)
+ changes = self.get_changes([], [self.author_name, self.book, self.edition])
+ # Right number/type of migrations?
+ self.assertNumberMigrations(changes, "testapp", 1)
+ self.assertOperationTypes(changes, "testapp", 0, ["CreateModel"])
+ self.assertOperationAttributes(changes, "testapp", 0, 0, name="Author")
+ self.assertMigrationDependencies(changes, "testapp", 0, [])
+ # Right number/type of migrations?
+ self.assertNumberMigrations(changes, "otherapp", 1)
+ self.assertOperationTypes(changes, "otherapp", 0, ["CreateModel"])
+ self.assertOperationAttributes(changes, "otherapp", 0, 0, name="Book")
+ self.assertMigrationDependencies(
+ changes, "otherapp", 0, [("testapp", "auto_1")]
+ )
+ # Right number/type of migrations?
+ self.assertNumberMigrations(changes, "thirdapp", 1)
+ self.assertOperationTypes(changes, "thirdapp", 0, ["CreateModel"])
+ self.assertOperationAttributes(changes, "thirdapp", 0, 0, name="Edition")
+ self.assertMigrationDependencies(
+ changes, "thirdapp", 0, [("otherapp", "auto_1")]
+ )
+
+ def test_proxy_fk_dependency(self):
+ """FK dependencies still work on proxy models."""
+ # Note that testapp (author) has no dependencies,
+ # otherapp (book) depends on testapp (authorproxy)
+ changes = self.get_changes(
+ [], [self.author_empty, self.author_proxy_third, self.book_proxy_fk]
+ )
+ # Right number/type of migrations?
+ self.assertNumberMigrations(changes, "testapp", 1)
+ self.assertOperationTypes(changes, "testapp", 0, ["CreateModel"])
+ self.assertOperationAttributes(changes, "testapp", 0, 0, name="Author")
+ self.assertMigrationDependencies(changes, "testapp", 0, [])
+ # Right number/type of migrations?
+ self.assertNumberMigrations(changes, "otherapp", 1)
+ self.assertOperationTypes(changes, "otherapp", 0, ["CreateModel"])
+ self.assertOperationAttributes(changes, "otherapp", 0, 0, name="Book")
+ self.assertMigrationDependencies(
+ changes, "otherapp", 0, [("thirdapp", "auto_1")]
+ )
+ # Right number/type of migrations?
+ self.assertNumberMigrations(changes, "thirdapp", 1)
+ self.assertOperationTypes(changes, "thirdapp", 0, ["CreateModel"])
+ self.assertOperationAttributes(changes, "thirdapp", 0, 0, name="AuthorProxy")
+ self.assertMigrationDependencies(
+ changes, "thirdapp", 0, [("testapp", "auto_1")]
+ )
+
+ def test_same_app_no_fk_dependency(self):
+ """
+ A migration with a FK between two models of the same app
+ does not have a dependency to itself.
+ """
+ changes = self.get_changes([], [self.author_with_publisher, self.publisher])
+ # Right number/type of migrations?
+ self.assertNumberMigrations(changes, "testapp", 1)
+ self.assertOperationTypes(changes, "testapp", 0, ["CreateModel", "CreateModel"])
+ self.assertOperationAttributes(changes, "testapp", 0, 0, name="Publisher")
+ self.assertOperationAttributes(changes, "testapp", 0, 1, name="Author")
+ self.assertMigrationDependencies(changes, "testapp", 0, [])
+
+ def test_circular_fk_dependency(self):
+ """
+ Having a circular ForeignKey dependency automatically
+ resolves the situation into 2 migrations on one side and 1 on the other.
+ """
+ changes = self.get_changes(
+ [], [self.author_with_book, self.book, self.publisher_with_book]
+ )
+ # Right number/type of migrations?
+ self.assertNumberMigrations(changes, "testapp", 1)
+ self.assertOperationTypes(changes, "testapp", 0, ["CreateModel", "CreateModel"])
+ self.assertOperationAttributes(changes, "testapp", 0, 0, name="Author")
+ self.assertOperationAttributes(changes, "testapp", 0, 1, name="Publisher")
+ self.assertMigrationDependencies(
+ changes, "testapp", 0, [("otherapp", "auto_1")]
+ )
+ # Right number/type of migrations?
+ self.assertNumberMigrations(changes, "otherapp", 2)
+ self.assertOperationTypes(changes, "otherapp", 0, ["CreateModel"])
+ self.assertOperationTypes(changes, "otherapp", 1, ["AddField"])
+ self.assertMigrationDependencies(changes, "otherapp", 0, [])
+ self.assertMigrationDependencies(
+ changes, "otherapp", 1, [("otherapp", "auto_1"), ("testapp", "auto_1")]
+ )
+ # both split migrations should be `initial`
+ self.assertTrue(changes["otherapp"][0].initial)
+ self.assertTrue(changes["otherapp"][1].initial)
+
+ def test_same_app_circular_fk_dependency(self):
+ """
+ A migration with a FK between two models of the same app does
+ not have a dependency to itself.
+ """
+ changes = self.get_changes(
+ [], [self.author_with_publisher, self.publisher_with_author]
+ )
+ # Right number/type of migrations?
+ self.assertNumberMigrations(changes, "testapp", 1)
+ self.assertOperationTypes(
+ changes, "testapp", 0, ["CreateModel", "CreateModel", "AddField"]
+ )
+ self.assertOperationAttributes(changes, "testapp", 0, 0, name="Author")
+ self.assertOperationAttributes(changes, "testapp", 0, 1, name="Publisher")
+ self.assertOperationAttributes(changes, "testapp", 0, 2, name="publisher")
+ self.assertMigrationDependencies(changes, "testapp", 0, [])
+
+ def test_same_app_circular_fk_dependency_with_unique_together_and_indexes(self):
+ """
+ #22275 - A migration with circular FK dependency does not try
+ to create unique together constraint and indexes before creating all
+ required fields first.
+ """
+ changes = self.get_changes([], [self.knight, self.rabbit])
+ # Right number/type of migrations?
+ self.assertNumberMigrations(changes, "eggs", 1)
+ self.assertOperationTypes(
+ changes,
+ "eggs",
+ 0,
+ ["CreateModel", "CreateModel"],
+ )
+ self.assertNotIn("unique_together", changes["eggs"][0].operations[0].options)
+ self.assertMigrationDependencies(changes, "eggs", 0, [])
+
+ def test_alter_db_table_add(self):
+ """Tests detection for adding db_table in model's options."""
+ changes = self.get_changes(
+ [self.author_empty], [self.author_with_db_table_options]
+ )
+ # Right number/type of migrations?
+ self.assertNumberMigrations(changes, "testapp", 1)
+ self.assertOperationTypes(changes, "testapp", 0, ["AlterModelTable"])
+ self.assertOperationAttributes(
+ changes, "testapp", 0, 0, name="author", table="author_one"
+ )
+
+ def test_alter_db_table_change(self):
+ """Tests detection for changing db_table in model's options'."""
+ changes = self.get_changes(
+ [self.author_with_db_table_options], [self.author_with_new_db_table_options]
+ )
+ # Right number/type of migrations?
+ self.assertNumberMigrations(changes, "testapp", 1)
+ self.assertOperationTypes(changes, "testapp", 0, ["AlterModelTable"])
+ self.assertOperationAttributes(
+ changes, "testapp", 0, 0, name="author", table="author_two"
+ )
+
+ def test_alter_db_table_remove(self):
+ """Tests detection for removing db_table in model's options."""
+ changes = self.get_changes(
+ [self.author_with_db_table_options], [self.author_empty]
+ )
+ # Right number/type of migrations?
+ self.assertNumberMigrations(changes, "testapp", 1)
+ self.assertOperationTypes(changes, "testapp", 0, ["AlterModelTable"])
+ self.assertOperationAttributes(
+ changes, "testapp", 0, 0, name="author", table=None
+ )
+
+ def test_alter_db_table_no_changes(self):
+ """
+ Alter_db_table doesn't generate a migration if no changes have been made.
+ """
+ changes = self.get_changes(
+ [self.author_with_db_table_options], [self.author_with_db_table_options]
+ )
+ # Right number of migrations?
+ self.assertEqual(len(changes), 0)
+
+ def test_keep_db_table_with_model_change(self):
+ """
+ Tests when model changes but db_table stays as-is, autodetector must not
+ create more than one operation.
+ """
+ changes = self.get_changes(
+ [self.author_with_db_table_options],
+ [self.author_renamed_with_db_table_options],
+ MigrationQuestioner({"ask_rename_model": True}),
+ )
+ # Right number/type of migrations?
+ self.assertNumberMigrations(changes, "testapp", 1)
+ self.assertOperationTypes(changes, "testapp", 0, ["RenameModel"])
+ self.assertOperationAttributes(
+ changes, "testapp", 0, 0, old_name="Author", new_name="NewAuthor"
+ )
+
+ def test_alter_db_table_with_model_change(self):
+ """
+ Tests when model and db_table changes, autodetector must create two
+ operations.
+ """
+ changes = self.get_changes(
+ [self.author_with_db_table_options],
+ [self.author_renamed_with_new_db_table_options],
+ MigrationQuestioner({"ask_rename_model": True}),
+ )
+ # Right number/type of migrations?
+ self.assertNumberMigrations(changes, "testapp", 1)
+ self.assertOperationTypes(
+ changes, "testapp", 0, ["RenameModel", "AlterModelTable"]
+ )
+ self.assertOperationAttributes(
+ changes, "testapp", 0, 0, old_name="Author", new_name="NewAuthor"
+ )
+ self.assertOperationAttributes(
+ changes, "testapp", 0, 1, name="newauthor", table="author_three"
+ )
+
+ def test_alter_db_table_comment_add(self):
+ changes = self.get_changes(
+ [self.author_empty], [self.author_with_db_table_comment]
+ )
+ self.assertNumberMigrations(changes, "testapp", 1)
+ self.assertOperationTypes(changes, "testapp", 0, ["AlterModelTableComment"])
+ self.assertOperationAttributes(
+ changes, "testapp", 0, 0, name="author", table_comment="Table comment"
+ )
+
+ def test_alter_db_table_comment_change(self):
+ author_with_new_db_table_comment = ModelState(
+ "testapp",
+ "Author",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ],
+ {"db_table_comment": "New table comment"},
+ )
+ changes = self.get_changes(
+ [self.author_with_db_table_comment],
+ [author_with_new_db_table_comment],
+ )
+ self.assertNumberMigrations(changes, "testapp", 1)
+ self.assertOperationTypes(changes, "testapp", 0, ["AlterModelTableComment"])
+ self.assertOperationAttributes(
+ changes,
+ "testapp",
+ 0,
+ 0,
+ name="author",
+ table_comment="New table comment",
+ )
+
+ def test_alter_db_table_comment_remove(self):
+ changes = self.get_changes(
+ [self.author_with_db_table_comment],
+ [self.author_empty],
+ )
+ self.assertNumberMigrations(changes, "testapp", 1)
+ self.assertOperationTypes(changes, "testapp", 0, ["AlterModelTableComment"])
+ self.assertOperationAttributes(
+ changes, "testapp", 0, 0, name="author", db_table_comment=None
+ )
+
+ def test_alter_db_table_comment_no_changes(self):
+ changes = self.get_changes(
+ [self.author_with_db_table_comment],
+ [self.author_with_db_table_comment],
+ )
+ self.assertNumberMigrations(changes, "testapp", 0)
+
+ def test_identical_regex_doesnt_alter(self):
+ from_state = ModelState(
+ "testapp",
+ "model",
+ [
+ (
+ "id",
+ models.AutoField(
+ primary_key=True,
+ validators=[
+ RegexValidator(
+ re.compile("^[-a-zA-Z0-9_]+\\Z"),
+ "Enter a valid “slug” consisting of letters, numbers, "
+ "underscores or hyphens.",
+ "invalid",
+ )
+ ],
+ ),
+ )
+ ],
+ )
+ to_state = ModelState(
+ "testapp",
+ "model",
+ [("id", models.AutoField(primary_key=True, validators=[validate_slug]))],
+ )
+ changes = self.get_changes([from_state], [to_state])
+ # Right number/type of migrations?
+ self.assertNumberMigrations(changes, "testapp", 0)
+
+ def test_different_regex_does_alter(self):
+ from_state = ModelState(
+ "testapp",
+ "model",
+ [
+ (
+ "id",
+ models.AutoField(
+ primary_key=True,
+ validators=[
+ RegexValidator(
+ re.compile("^[a-z]+\\Z", 32),
+ "Enter a valid “slug” consisting of letters, numbers, "
+ "underscores or hyphens.",
+ "invalid",
+ )
+ ],
+ ),
+ )
+ ],
+ )
+ to_state = ModelState(
+ "testapp",
+ "model",
+ [("id", models.AutoField(primary_key=True, validators=[validate_slug]))],
+ )
+ changes = self.get_changes([from_state], [to_state])
+ self.assertNumberMigrations(changes, "testapp", 1)
+ self.assertOperationTypes(changes, "testapp", 0, ["AlterField"])
+
+ def test_alter_regex_string_to_compiled_regex(self):
+ regex_string = "^[a-z]+$"
+ from_state = ModelState(
+ "testapp",
+ "model",
+ [
+ (
+ "id",
+ models.AutoField(
+ primary_key=True, validators=[RegexValidator(regex_string)]
+ ),
+ )
+ ],
+ )
+ to_state = ModelState(
+ "testapp",
+ "model",
+ [
+ (
+ "id",
+ models.AutoField(
+ primary_key=True,
+ validators=[RegexValidator(re.compile(regex_string))],
+ ),
+ )
+ ],
+ )
+ changes = self.get_changes([from_state], [to_state])
+ self.assertNumberMigrations(changes, "testapp", 1)
+ self.assertOperationTypes(changes, "testapp", 0, ["AlterField"])
+
+ def test_empty_unique_together(self):
+ """Empty unique_together shouldn't generate a migration."""
+ # Explicitly testing for not specified, since this is the case after
+ # a CreateModel operation w/o any definition on the original model
+ model_state_not_specified = ModelState(
+ "a", "model", [("id", models.AutoField(primary_key=True))]
+ )
+ # Explicitly testing for None, since this was the issue in #23452 after
+ # an AlterUniqueTogether operation with e.g. () as value
+ model_state_none = ModelState(
+ "a",
+ "model",
+ [("id", models.AutoField(primary_key=True))],
+ {
+ "unique_together": None,
+ },
+ )
+ # Explicitly testing for the empty set, since we now always have sets.
+ # During removal (('col1', 'col2'),) --> () this becomes set([])
+ model_state_empty = ModelState(
+ "a",
+ "model",
+ [("id", models.AutoField(primary_key=True))],
+ {
+ "unique_together": set(),
+ },
+ )
+
+ def test(from_state, to_state, msg):
+ changes = self.get_changes([from_state], [to_state])
+ if changes:
+ ops = ", ".join(
+ o.__class__.__name__ for o in changes["a"][0].operations
+ )
+ self.fail("Created operation(s) %s from %s" % (ops, msg))
+
+ tests = (
+ (
+ model_state_not_specified,
+ model_state_not_specified,
+ '"not specified" to "not specified"',
+ ),
+ (model_state_not_specified, model_state_none, '"not specified" to "None"'),
+ (
+ model_state_not_specified,
+ model_state_empty,
+ '"not specified" to "empty"',
+ ),
+ (model_state_none, model_state_not_specified, '"None" to "not specified"'),
+ (model_state_none, model_state_none, '"None" to "None"'),
+ (model_state_none, model_state_empty, '"None" to "empty"'),
+ (
+ model_state_empty,
+ model_state_not_specified,
+ '"empty" to "not specified"',
+ ),
+ (model_state_empty, model_state_none, '"empty" to "None"'),
+ (model_state_empty, model_state_empty, '"empty" to "empty"'),
+ )
+
+ for t in tests:
+ test(*t)
+
+ def test_create_model_with_indexes(self):
+ """Test creation of new model with indexes already defined."""
+ added_index = models.Index(
+ fields=["name"], name="create_model_with_indexes_idx"
+ )
+ author = ModelState(
+ "otherapp",
+ "Author",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ("name", models.CharField(max_length=200)),
+ ],
+ {
+ "indexes": [added_index],
+ },
+ )
+ changes = self.get_changes([], [author])
+ # Right number of migrations?
+ self.assertEqual(len(changes["otherapp"]), 1)
+ # Right number of actions?
+ migration = changes["otherapp"][0]
+ self.assertEqual(len(migration.operations), 1)
+ # Right actions order?
+ self.assertOperationTypes(changes, "otherapp", 0, ["CreateModel"])
+ self.assertOperationAttributes(changes, "otherapp", 0, 0, name="Author")
+ self.assertOperationAttributes(
+ changes,
+ "otherapp",
+ 0,
+ 0,
+ name="Author",
+ options={"indexes": [added_index]},
+ )
+
+ def test_add_indexes(self):
+ """Test change detection of new indexes."""
+ changes = self.get_changes(
+ [self.author_empty, self.book], [self.author_empty, self.book_indexes]
+ )
+ self.assertNumberMigrations(changes, "otherapp", 1)
+ self.assertOperationTypes(changes, "otherapp", 0, ["AddIndex"])
+ added_index = models.Index(
+ fields=["author", "title"], name="book_title_author_idx"
+ )
+ self.assertOperationAttributes(
+ changes, "otherapp", 0, 0, model_name="book", index=added_index
+ )
+
+ def test_remove_indexes(self):
+ """Test change detection of removed indexes."""
+ changes = self.get_changes(
+ [self.author_empty, self.book_indexes], [self.author_empty, self.book]
+ )
+ # Right number/type of migrations?
+ self.assertNumberMigrations(changes, "otherapp", 1)
+ self.assertOperationTypes(changes, "otherapp", 0, ["RemoveIndex"])
+ self.assertOperationAttributes(
+ changes, "otherapp", 0, 0, model_name="book", name="book_title_author_idx"
+ )
+
+ def test_rename_indexes(self):
+ book_renamed_indexes = ModelState(
+ "otherapp",
+ "Book",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ("author", models.ForeignKey("testapp.Author", models.CASCADE)),
+ ("title", models.CharField(max_length=200)),
+ ],
+ {
+ "indexes": [
+ models.Index(
+ fields=["author", "title"], name="renamed_book_title_author_idx"
+ )
+ ],
+ },
+ )
+ changes = self.get_changes(
+ [self.author_empty, self.book_indexes],
+ [self.author_empty, book_renamed_indexes],
+ )
+ self.assertNumberMigrations(changes, "otherapp", 1)
+ self.assertOperationTypes(changes, "otherapp", 0, ["RenameIndex"])
+ self.assertOperationAttributes(
+ changes,
+ "otherapp",
+ 0,
+ 0,
+ model_name="book",
+ new_name="renamed_book_title_author_idx",
+ old_name="book_title_author_idx",
+ )
+
+ def test_order_fields_indexes(self):
+ """Test change detection of reordering of fields in indexes."""
+ changes = self.get_changes(
+ [self.author_empty, self.book_indexes],
+ [self.author_empty, self.book_unordered_indexes],
+ )
+ self.assertNumberMigrations(changes, "otherapp", 1)
+ self.assertOperationTypes(changes, "otherapp", 0, ["RemoveIndex", "AddIndex"])
+ self.assertOperationAttributes(
+ changes, "otherapp", 0, 0, model_name="book", name="book_title_author_idx"
+ )
+ added_index = models.Index(
+ fields=["title", "author"], name="book_author_title_idx"
+ )
+ self.assertOperationAttributes(
+ changes, "otherapp", 0, 1, model_name="book", index=added_index
+ )
+
+ def test_create_model_with_check_constraint(self):
+ """Test creation of new model with constraints already defined."""
+ author = ModelState(
+ "otherapp",
+ "Author",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ("name", models.CharField(max_length=200)),
+ ],
+ {
+ "constraints": [
+ models.CheckConstraint(
+ check=models.Q(name__contains="Bob"), name="name_contains_bob"
+ )
+ ]
+ },
+ )
+ changes = self.get_changes([], [author])
+ added_constraint = models.CheckConstraint(
+ check=models.Q(name__contains="Bob"), name="name_contains_bob"
+ )
+ # Right number of migrations?
+ self.assertEqual(len(changes["otherapp"]), 1)
+ # Right number of actions?
+ migration = changes["otherapp"][0]
+ self.assertEqual(len(migration.operations), 2)
+ # Right actions order?
+ self.assertOperationTypes(
+ changes, "otherapp", 0, ["CreateModel", "AddConstraint"]
+ )
+ self.assertOperationAttributes(changes, "otherapp", 0, 0, name="Author")
+ self.assertOperationAttributes(
+ changes, "otherapp", 0, 1, model_name="author", constraint=added_constraint
+ )
+
+ def test_add_constraints(self):
+ """Test change detection of new constraints."""
+ changes = self.get_changes(
+ [self.author_name], [self.author_name_check_constraint]
+ )
+ self.assertNumberMigrations(changes, "testapp", 1)
+ self.assertOperationTypes(changes, "testapp", 0, ["AddConstraint"])
+ added_constraint = models.CheckConstraint(
+ check=models.Q(name__contains="Bob"), name="name_contains_bob"
+ )
+ self.assertOperationAttributes(
+ changes, "testapp", 0, 0, model_name="author", constraint=added_constraint
+ )
+
+ def test_add_constraints_with_new_model(self):
+ book_with_unique_title_and_pony = ModelState(
+ "otherapp",
+ "Book",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ("title", models.CharField(max_length=200)),
+ ("pony", models.ForeignKey("otherapp.Pony", models.CASCADE)),
+ ],
+ {
+ "constraints": [
+ models.UniqueConstraint(
+ fields=["title", "pony"],
+ name="unique_title_pony",
+ )
+ ]
+ },
+ )
+ changes = self.get_changes(
+ [self.book_with_no_author],
+ [book_with_unique_title_and_pony, self.other_pony],
+ )
+
+ self.assertNumberMigrations(changes, "otherapp", 1)
+ self.assertOperationTypes(
+ changes,
+ "otherapp",
+ 0,
+ ["CreateModel", "AddField", "AddConstraint"],
+ )
+
+ def test_add_index_with_new_model(self):
+ book_with_index_title_and_pony = ModelState(
+ "otherapp",
+ "Book",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ("title", models.CharField(max_length=200)),
+ ("pony", models.ForeignKey("otherapp.Pony", models.CASCADE)),
+ ],
+ {
+ "indexes": [
+ models.Index(fields=["title", "pony"], name="index_title_pony"),
+ ]
+ },
+ )
+ changes = self.get_changes(
+ [self.book_with_no_author],
+ [book_with_index_title_and_pony, self.other_pony],
+ )
+
+ self.assertNumberMigrations(changes, "otherapp", 1)
+ self.assertOperationTypes(
+ changes,
+ "otherapp",
+ 0,
+ ["CreateModel", "AddField", "AddIndex"],
+ )
+
+ def test_remove_constraints(self):
+ """Test change detection of removed constraints."""
+ changes = self.get_changes(
+ [self.author_name_check_constraint], [self.author_name]
+ )
+ # Right number/type of migrations?
+ self.assertNumberMigrations(changes, "testapp", 1)
+ self.assertOperationTypes(changes, "testapp", 0, ["RemoveConstraint"])
+ self.assertOperationAttributes(
+ changes, "testapp", 0, 0, model_name="author", name="name_contains_bob"
+ )
+
+ def test_add_unique_together(self):
+ """Tests unique_together detection."""
+ changes = self.get_changes(
+ [self.author_empty, self.book],
+ [self.author_empty, self.book_unique_together],
+ )
+ # Right number/type of migrations?
+ self.assertNumberMigrations(changes, "otherapp", 1)
+ self.assertOperationTypes(changes, "otherapp", 0, ["AlterUniqueTogether"])
+ self.assertOperationAttributes(
+ changes,
+ "otherapp",
+ 0,
+ 0,
+ name="book",
+ unique_together={("author", "title")},
+ )
+
+ def test_remove_unique_together(self):
+ """Tests unique_together detection."""
+ changes = self.get_changes(
+ [self.author_empty, self.book_unique_together],
+ [self.author_empty, self.book],
+ )
+ # Right number/type of migrations?
+ self.assertNumberMigrations(changes, "otherapp", 1)
+ self.assertOperationTypes(changes, "otherapp", 0, ["AlterUniqueTogether"])
+ self.assertOperationAttributes(
+ changes, "otherapp", 0, 0, name="book", unique_together=set()
+ )
+
+ def test_unique_together_remove_fk(self):
+ """Tests unique_together and field removal detection & ordering"""
+ changes = self.get_changes(
+ [self.author_empty, self.book_unique_together],
+ [self.author_empty, self.book_with_no_author],
+ )
+ # Right number/type of migrations?
+ self.assertNumberMigrations(changes, "otherapp", 1)
+ self.assertOperationTypes(
+ changes,
+ "otherapp",
+ 0,
+ ["AlterUniqueTogether", "RemoveField"],
+ )
+ self.assertOperationAttributes(
+ changes, "otherapp", 0, 0, name="book", unique_together=set()
+ )
+ self.assertOperationAttributes(
+ changes, "otherapp", 0, 1, model_name="book", name="author"
+ )
+
+ def test_unique_together_no_changes(self):
+ """
+ unique_together doesn't generate a migration if no
+ changes have been made.
+ """
+ changes = self.get_changes(
+ [self.author_empty, self.book_unique_together],
+ [self.author_empty, self.book_unique_together],
+ )
+ # Right number of migrations?
+ self.assertEqual(len(changes), 0)
+
+ def test_unique_together_ordering(self):
+ """
+ unique_together also triggers on ordering changes.
+ """
+ changes = self.get_changes(
+ [self.author_empty, self.book_unique_together],
+ [self.author_empty, self.book_unique_together_2],
+ )
+ # Right number/type of migrations?
+ self.assertNumberMigrations(changes, "otherapp", 1)
+ self.assertOperationTypes(
+ changes,
+ "otherapp",
+ 0,
+ ["AlterUniqueTogether"],
+ )
+ self.assertOperationAttributes(
+ changes,
+ "otherapp",
+ 0,
+ 0,
+ name="book",
+ unique_together={("title", "author")},
+ )
+
+ def test_add_field_and_unique_together(self):
+ """
+ Added fields will be created before using them in unique_together.
+ """
+ changes = self.get_changes(
+ [self.author_empty, self.book],
+ [self.author_empty, self.book_unique_together_3],
+ )
+ # Right number/type of migrations?
+ self.assertNumberMigrations(changes, "otherapp", 1)
+ self.assertOperationTypes(
+ changes,
+ "otherapp",
+ 0,
+ ["AddField", "AlterUniqueTogether"],
+ )
+ self.assertOperationAttributes(
+ changes,
+ "otherapp",
+ 0,
+ 1,
+ name="book",
+ unique_together={("title", "newfield")},
+ )
+
+ def test_create_model_and_unique_together(self):
+ author = ModelState(
+ "otherapp",
+ "Author",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ("name", models.CharField(max_length=200)),
+ ],
+ )
+ book_with_author = ModelState(
+ "otherapp",
+ "Book",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ("author", models.ForeignKey("otherapp.Author", models.CASCADE)),
+ ("title", models.CharField(max_length=200)),
+ ],
+ {
+ "unique_together": {("title", "author")},
+ },
+ )
+ changes = self.get_changes(
+ [self.book_with_no_author], [author, book_with_author]
+ )
+ # Right number of migrations?
+ self.assertEqual(len(changes["otherapp"]), 1)
+ # Right number of actions?
+ migration = changes["otherapp"][0]
+ self.assertEqual(len(migration.operations), 3)
+ # Right actions order?
+ self.assertOperationTypes(
+ changes,
+ "otherapp",
+ 0,
+ ["CreateModel", "AddField", "AlterUniqueTogether"],
+ )
+
+ def test_remove_field_and_unique_together(self):
+ """
+ Removed fields will be removed after updating unique_together.
+ """
+ changes = self.get_changes(
+ [self.author_empty, self.book_unique_together_3],
+ [self.author_empty, self.book_unique_together],
+ )
+ # Right number/type of migrations?
+ self.assertNumberMigrations(changes, "otherapp", 1)
+ self.assertOperationTypes(
+ changes,
+ "otherapp",
+ 0,
+ ["AlterUniqueTogether", "RemoveField"],
+ )
+ self.assertOperationAttributes(
+ changes,
+ "otherapp",
+ 0,
+ 0,
+ name="book",
+ unique_together={("author", "title")},
+ )
+ self.assertOperationAttributes(
+ changes,
+ "otherapp",
+ 0,
+ 1,
+ model_name="book",
+ name="newfield",
+ )
+
+ def test_alter_field_and_unique_together(self):
+ """Fields are altered after deleting some unique_together."""
+ initial_author = ModelState(
+ "testapp",
+ "Author",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ("name", models.CharField(max_length=200)),
+ ("age", models.IntegerField(db_index=True)),
+ ],
+ {
+ "unique_together": {("name",)},
+ },
+ )
+ author_reversed_constraints = ModelState(
+ "testapp",
+ "Author",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ("name", models.CharField(max_length=200, unique=True)),
+ ("age", models.IntegerField()),
+ ],
+ {
+ "unique_together": {("age",)},
+ },
+ )
+ changes = self.get_changes([initial_author], [author_reversed_constraints])
+
+ self.assertNumberMigrations(changes, "testapp", 1)
+ self.assertOperationTypes(
+ changes,
+ "testapp",
+ 0,
+ [
+ "AlterUniqueTogether",
+ "AlterField",
+ "AlterField",
+ "AlterUniqueTogether",
+ ],
+ )
+ self.assertOperationAttributes(
+ changes,
+ "testapp",
+ 0,
+ 0,
+ name="author",
+ unique_together=set(),
+ )
+ self.assertOperationAttributes(
+ changes,
+ "testapp",
+ 0,
+ 1,
+ model_name="author",
+ name="age",
+ )
+ self.assertOperationAttributes(
+ changes,
+ "testapp",
+ 0,
+ 2,
+ model_name="author",
+ name="name",
+ )
+ self.assertOperationAttributes(
+ changes,
+ "testapp",
+ 0,
+ 3,
+ name="author",
+ unique_together={("age",)},
+ )
+
+ def test_partly_alter_unique_together_increase(self):
+ initial_author = ModelState(
+ "testapp",
+ "Author",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ("name", models.CharField(max_length=200)),
+ ("age", models.IntegerField()),
+ ],
+ {
+ "unique_together": {("name",)},
+ },
+ )
+ author_new_constraints = ModelState(
+ "testapp",
+ "Author",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ("name", models.CharField(max_length=200)),
+ ("age", models.IntegerField()),
+ ],
+ {
+ "unique_together": {("name",), ("age",)},
+ },
+ )
+ changes = self.get_changes([initial_author], [author_new_constraints])
+
+ self.assertNumberMigrations(changes, "testapp", 1)
+ self.assertOperationTypes(
+ changes,
+ "testapp",
+ 0,
+ ["AlterUniqueTogether"],
+ )
+ self.assertOperationAttributes(
+ changes,
+ "testapp",
+ 0,
+ 0,
+ name="author",
+ unique_together={("name",), ("age",)},
+ )
+
+ def test_partly_alter_unique_together_decrease(self):
+ initial_author = ModelState(
+ "testapp",
+ "Author",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ("name", models.CharField(max_length=200)),
+ ("age", models.IntegerField()),
+ ],
+ {
+ "unique_together": {("name",), ("age",)},
+ },
+ )
+ author_new_constraints = ModelState(
+ "testapp",
+ "Author",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ("name", models.CharField(max_length=200)),
+ ("age", models.IntegerField()),
+ ],
+ {
+ "unique_together": {("name",)},
+ },
+ )
+ changes = self.get_changes([initial_author], [author_new_constraints])
+
+ self.assertNumberMigrations(changes, "testapp", 1)
+ self.assertOperationTypes(
+ changes,
+ "testapp",
+ 0,
+ ["AlterUniqueTogether"],
+ )
+ self.assertOperationAttributes(
+ changes,
+ "testapp",
+ 0,
+ 0,
+ name="author",
+ unique_together={("name",)},
+ )
+
+ def test_rename_field_and_unique_together(self):
+ """Fields are renamed before updating unique_together."""
+ changes = self.get_changes(
+ [self.author_empty, self.book_unique_together_3],
+ [self.author_empty, self.book_unique_together_4],
+ MigrationQuestioner({"ask_rename": True}),
+ )
+ # Right number/type of migrations?
+ self.assertNumberMigrations(changes, "otherapp", 1)
+ self.assertOperationTypes(
+ changes,
+ "otherapp",
+ 0,
+ ["RenameField", "AlterUniqueTogether"],
+ )
+ self.assertOperationAttributes(
+ changes,
+ "otherapp",
+ 0,
+ 1,
+ name="book",
+ unique_together={("title", "newfield2")},
+ )
+
+ def test_proxy(self):
+ """The autodetector correctly deals with proxy models."""
+ # First, we test adding a proxy model
+ changes = self.get_changes(
+ [self.author_empty], [self.author_empty, self.author_proxy]
+ )
+ # Right number/type of migrations?
+ self.assertNumberMigrations(changes, "testapp", 1)
+ self.assertOperationTypes(changes, "testapp", 0, ["CreateModel"])
+ self.assertOperationAttributes(
+ changes,
+ "testapp",
+ 0,
+ 0,
+ name="AuthorProxy",
+ options={"proxy": True, "indexes": [], "constraints": []},
+ )
+ # Now, we test turning a proxy model into a non-proxy model
+ # It should delete the proxy then make the real one
+ changes = self.get_changes(
+ [self.author_empty, self.author_proxy],
+ [self.author_empty, self.author_proxy_notproxy],
+ )
+ # Right number/type of migrations?
+ self.assertNumberMigrations(changes, "testapp", 1)
+ self.assertOperationTypes(changes, "testapp", 0, ["DeleteModel", "CreateModel"])
+ self.assertOperationAttributes(changes, "testapp", 0, 0, name="AuthorProxy")
+ self.assertOperationAttributes(
+ changes, "testapp", 0, 1, name="AuthorProxy", options={}
+ )
+
+ def test_proxy_non_model_parent(self):
+ class Mixin:
+ pass
+
+ author_proxy_non_model_parent = ModelState(
+ "testapp",
+ "AuthorProxy",
+ [],
+ {"proxy": True},
+ (Mixin, "testapp.author"),
+ )
+ changes = self.get_changes(
+ [self.author_empty],
+ [self.author_empty, author_proxy_non_model_parent],
+ )
+ self.assertNumberMigrations(changes, "testapp", 1)
+ self.assertOperationTypes(changes, "testapp", 0, ["CreateModel"])
+ self.assertOperationAttributes(
+ changes,
+ "testapp",
+ 0,
+ 0,
+ name="AuthorProxy",
+ options={"proxy": True, "indexes": [], "constraints": []},
+ bases=(Mixin, "testapp.author"),
+ )
+
+ def test_proxy_custom_pk(self):
+ """
+ #23415 - The autodetector must correctly deal with custom FK on proxy
+ models.
+ """
+ # First, we test the default pk field name
+ changes = self.get_changes(
+ [], [self.author_empty, self.author_proxy_third, self.book_proxy_fk]
+ )
+ # The model the FK is pointing from and to.
+ self.assertEqual(
+ changes["otherapp"][0].operations[0].fields[2][1].remote_field.model,
+ "thirdapp.AuthorProxy",
+ )
+ # Now, we test the custom pk field name
+ changes = self.get_changes(
+ [], [self.author_custom_pk, self.author_proxy_third, self.book_proxy_fk]
+ )
+ # The model the FK is pointing from and to.
+ self.assertEqual(
+ changes["otherapp"][0].operations[0].fields[2][1].remote_field.model,
+ "thirdapp.AuthorProxy",
+ )
+
+ def test_proxy_to_mti_with_fk_to_proxy(self):
+ # First, test the pk table and field name.
+ to_state = self.make_project_state(
+ [self.author_empty, self.author_proxy_third, self.book_proxy_fk],
+ )
+ changes = self.get_changes([], to_state)
+ fk_field = changes["otherapp"][0].operations[0].fields[2][1]
+ self.assertEqual(
+ to_state.get_concrete_model_key(fk_field.remote_field.model),
+ ("testapp", "author"),
+ )
+ self.assertEqual(fk_field.remote_field.model, "thirdapp.AuthorProxy")
+
+ # Change AuthorProxy to use MTI.
+ from_state = to_state.clone()
+ to_state = self.make_project_state(
+ [self.author_empty, self.author_proxy_third_notproxy, self.book_proxy_fk],
+ )
+ changes = self.get_changes(from_state, to_state)
+ # Right number/type of migrations for the AuthorProxy model?
+ self.assertNumberMigrations(changes, "thirdapp", 1)
+ self.assertOperationTypes(
+ changes, "thirdapp", 0, ["DeleteModel", "CreateModel"]
+ )
+ # Right number/type of migrations for the Book model with a FK to
+ # AuthorProxy?
+ self.assertNumberMigrations(changes, "otherapp", 1)
+ self.assertOperationTypes(changes, "otherapp", 0, ["AlterField"])
+ # otherapp should depend on thirdapp.
+ self.assertMigrationDependencies(
+ changes, "otherapp", 0, [("thirdapp", "auto_1")]
+ )
+ # Now, test the pk table and field name.
+ fk_field = changes["otherapp"][0].operations[0].field
+ self.assertEqual(
+ to_state.get_concrete_model_key(fk_field.remote_field.model),
+ ("thirdapp", "authorproxy"),
+ )
+ self.assertEqual(fk_field.remote_field.model, "thirdapp.AuthorProxy")
+
+ def test_proxy_to_mti_with_fk_to_proxy_proxy(self):
+ # First, test the pk table and field name.
+ to_state = self.make_project_state(
+ [
+ self.author_empty,
+ self.author_proxy,
+ self.author_proxy_proxy,
+ self.book_proxy_proxy_fk,
+ ]
+ )
+ changes = self.get_changes([], to_state)
+ fk_field = changes["otherapp"][0].operations[0].fields[1][1]
+ self.assertEqual(
+ to_state.get_concrete_model_key(fk_field.remote_field.model),
+ ("testapp", "author"),
+ )
+ self.assertEqual(fk_field.remote_field.model, "testapp.AAuthorProxyProxy")
+
+ # Change AuthorProxy to use MTI. FK still points to AAuthorProxyProxy,
+ # a proxy of AuthorProxy.
+ from_state = to_state.clone()
+ to_state = self.make_project_state(
+ [
+ self.author_empty,
+ self.author_proxy_notproxy,
+ self.author_proxy_proxy,
+ self.book_proxy_proxy_fk,
+ ]
+ )
+ changes = self.get_changes(from_state, to_state)
+ # Right number/type of migrations for the AuthorProxy model?
+ self.assertNumberMigrations(changes, "testapp", 1)
+ self.assertOperationTypes(changes, "testapp", 0, ["DeleteModel", "CreateModel"])
+ # Right number/type of migrations for the Book model with a FK to
+ # AAuthorProxyProxy?
+ self.assertNumberMigrations(changes, "otherapp", 1)
+ self.assertOperationTypes(changes, "otherapp", 0, ["AlterField"])
+ # otherapp should depend on testapp.
+ self.assertMigrationDependencies(
+ changes, "otherapp", 0, [("testapp", "auto_1")]
+ )
+ # Now, test the pk table and field name.
+ fk_field = changes["otherapp"][0].operations[0].field
+ self.assertEqual(
+ to_state.get_concrete_model_key(fk_field.remote_field.model),
+ ("testapp", "authorproxy"),
+ )
+ self.assertEqual(fk_field.remote_field.model, "testapp.AAuthorProxyProxy")
+
+ def test_unmanaged_create(self):
+ """The autodetector correctly deals with managed models."""
+ # First, we test adding an unmanaged model
+ changes = self.get_changes(
+ [self.author_empty], [self.author_empty, self.author_unmanaged]
+ )
+ # Right number/type of migrations?
+ self.assertNumberMigrations(changes, "testapp", 1)
+ self.assertOperationTypes(changes, "testapp", 0, ["CreateModel"])
+ self.assertOperationAttributes(
+ changes, "testapp", 0, 0, name="AuthorUnmanaged", options={"managed": False}
+ )
+
+ def test_unmanaged_delete(self):
+ changes = self.get_changes(
+ [self.author_empty, self.author_unmanaged], [self.author_empty]
+ )
+ self.assertNumberMigrations(changes, "testapp", 1)
+ self.assertOperationTypes(changes, "testapp", 0, ["DeleteModel"])
+
+ def test_unmanaged_to_managed(self):
+ # Now, we test turning an unmanaged model into a managed model
+ changes = self.get_changes(
+ [self.author_empty, self.author_unmanaged],
+ [self.author_empty, self.author_unmanaged_managed],
+ )
+ # Right number/type of migrations?
+ self.assertNumberMigrations(changes, "testapp", 1)
+ self.assertOperationTypes(changes, "testapp", 0, ["AlterModelOptions"])
+ self.assertOperationAttributes(
+ changes, "testapp", 0, 0, name="authorunmanaged", options={}
+ )
+
+ def test_managed_to_unmanaged(self):
+ # Now, we turn managed to unmanaged.
+ changes = self.get_changes(
+ [self.author_empty, self.author_unmanaged_managed],
+ [self.author_empty, self.author_unmanaged],
+ )
+ # Right number/type of migrations?
+ self.assertNumberMigrations(changes, "testapp", 1)
+ self.assertOperationTypes(changes, "testapp", 0, ["AlterModelOptions"])
+ self.assertOperationAttributes(
+ changes, "testapp", 0, 0, name="authorunmanaged", options={"managed": False}
+ )
+
+ def test_unmanaged_custom_pk(self):
+ """
+ #23415 - The autodetector must correctly deal with custom FK on
+ unmanaged models.
+ """
+ # First, we test the default pk field name
+ changes = self.get_changes([], [self.author_unmanaged_default_pk, self.book])
+ # The model the FK on the book model points to.
+ fk_field = changes["otherapp"][0].operations[0].fields[2][1]
+ self.assertEqual(fk_field.remote_field.model, "testapp.Author")
+ # Now, we test the custom pk field name
+ changes = self.get_changes([], [self.author_unmanaged_custom_pk, self.book])
+ # The model the FK on the book model points to.
+ fk_field = changes["otherapp"][0].operations[0].fields[2][1]
+ self.assertEqual(fk_field.remote_field.model, "testapp.Author")
+
+ @override_settings(AUTH_USER_MODEL="thirdapp.CustomUser")
+ def test_swappable(self):
+ with isolate_lru_cache(apps.get_swappable_settings_name):
+ changes = self.get_changes(
+ [self.custom_user], [self.custom_user, self.author_with_custom_user]
+ )
+ # Right number/type of migrations?
+ self.assertNumberMigrations(changes, "testapp", 1)
+ self.assertOperationTypes(changes, "testapp", 0, ["CreateModel"])
+ self.assertOperationAttributes(changes, "testapp", 0, 0, name="Author")
+ self.assertMigrationDependencies(
+ changes, "testapp", 0, [("__setting__", "AUTH_USER_MODEL")]
+ )
+
+ def test_swappable_lowercase(self):
+ model_state = ModelState(
+ "testapp",
+ "Document",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ (
+ "owner",
+ models.ForeignKey(
+ settings.AUTH_USER_MODEL.lower(),
+ models.CASCADE,
+ ),
+ ),
+ ],
+ )
+ with isolate_lru_cache(apps.get_swappable_settings_name):
+ changes = self.get_changes([], [model_state])
+ self.assertNumberMigrations(changes, "testapp", 1)
+ self.assertOperationTypes(changes, "testapp", 0, ["CreateModel"])
+ self.assertOperationAttributes(changes, "testapp", 0, 0, name="Document")
+ self.assertMigrationDependencies(
+ changes,
+ "testapp",
+ 0,
+ [("__setting__", "AUTH_USER_MODEL")],
+ )
+
+ @override_settings(AUTH_USER_MODEL="thirdapp.CustomUser")
+ def test_swappable_many_to_many_model_case(self):
+ document_lowercase = ModelState(
+ "testapp",
+ "Document",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ("owners", models.ManyToManyField(settings.AUTH_USER_MODEL.lower())),
+ ],
+ )
+ document = ModelState(
+ "testapp",
+ "Document",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ("owners", models.ManyToManyField(settings.AUTH_USER_MODEL)),
+ ],
+ )
+ with isolate_lru_cache(apps.get_swappable_settings_name):
+ changes = self.get_changes(
+ [self.custom_user, document_lowercase],
+ [self.custom_user, document],
+ )
+ self.assertEqual(len(changes), 0)
+
+ def test_swappable_changed(self):
+ with isolate_lru_cache(apps.get_swappable_settings_name):
+ before = self.make_project_state([self.custom_user, self.author_with_user])
+ with override_settings(AUTH_USER_MODEL="thirdapp.CustomUser"):
+ after = self.make_project_state(
+ [self.custom_user, self.author_with_custom_user]
+ )
+ autodetector = MigrationAutodetector(before, after)
+ changes = autodetector._detect_changes()
+ # Right number/type of migrations?
+ self.assertNumberMigrations(changes, "testapp", 1)
+ self.assertOperationTypes(changes, "testapp", 0, ["AlterField"])
+ self.assertOperationAttributes(
+ changes, "testapp", 0, 0, model_name="author", name="user"
+ )
+ fk_field = changes["testapp"][0].operations[0].field
+ self.assertEqual(fk_field.remote_field.model, "thirdapp.CustomUser")
+
+ def test_add_field_with_default(self):
+ """#22030 - Adding a field with a default should work."""
+ changes = self.get_changes([self.author_empty], [self.author_name_default])
+ # Right number/type of migrations?
+ self.assertNumberMigrations(changes, "testapp", 1)
+ self.assertOperationTypes(changes, "testapp", 0, ["AddField"])
+ self.assertOperationAttributes(changes, "testapp", 0, 0, name="name")
+
+ def test_custom_deconstructible(self):
+ """
+ Two instances which deconstruct to the same value aren't considered a
+ change.
+ """
+ changes = self.get_changes(
+ [self.author_name_deconstructible_1], [self.author_name_deconstructible_2]
+ )
+ # Right number of migrations?
+ self.assertEqual(len(changes), 0)
+
+ def test_deconstruct_field_kwarg(self):
+ """Field instances are handled correctly by nested deconstruction."""
+ changes = self.get_changes(
+ [self.author_name_deconstructible_3], [self.author_name_deconstructible_4]
+ )
+ self.assertEqual(changes, {})
+
+ def test_deconstructible_list(self):
+ """Nested deconstruction descends into lists."""
+ # When lists contain items that deconstruct to identical values, those lists
+ # should be considered equal for the purpose of detecting state changes
+ # (even if the original items are unequal).
+ changes = self.get_changes(
+ [self.author_name_deconstructible_list_1],
+ [self.author_name_deconstructible_list_2],
+ )
+ self.assertEqual(changes, {})
+ # Legitimate differences within the deconstructed lists should be reported
+ # as a change
+ changes = self.get_changes(
+ [self.author_name_deconstructible_list_1],
+ [self.author_name_deconstructible_list_3],
+ )
+ self.assertEqual(len(changes), 1)
+
+ def test_deconstructible_tuple(self):
+ """Nested deconstruction descends into tuples."""
+ # When tuples contain items that deconstruct to identical values, those tuples
+ # should be considered equal for the purpose of detecting state changes
+ # (even if the original items are unequal).
+ changes = self.get_changes(
+ [self.author_name_deconstructible_tuple_1],
+ [self.author_name_deconstructible_tuple_2],
+ )
+ self.assertEqual(changes, {})
+ # Legitimate differences within the deconstructed tuples should be reported
+ # as a change
+ changes = self.get_changes(
+ [self.author_name_deconstructible_tuple_1],
+ [self.author_name_deconstructible_tuple_3],
+ )
+ self.assertEqual(len(changes), 1)
+
+ def test_deconstructible_dict(self):
+ """Nested deconstruction descends into dict values."""
+ # When dicts contain items whose values deconstruct to identical values,
+ # those dicts should be considered equal for the purpose of detecting
+ # state changes (even if the original values are unequal).
+ changes = self.get_changes(
+ [self.author_name_deconstructible_dict_1],
+ [self.author_name_deconstructible_dict_2],
+ )
+ self.assertEqual(changes, {})
+ # Legitimate differences within the deconstructed dicts should be reported
+ # as a change
+ changes = self.get_changes(
+ [self.author_name_deconstructible_dict_1],
+ [self.author_name_deconstructible_dict_3],
+ )
+ self.assertEqual(len(changes), 1)
+
+ def test_nested_deconstructible_objects(self):
+ """
+ Nested deconstruction is applied recursively to the args/kwargs of
+ deconstructed objects.
+ """
+ # If the items within a deconstructed object's args/kwargs have the same
+ # deconstructed values - whether or not the items themselves are different
+ # instances - then the object as a whole is regarded as unchanged.
+ changes = self.get_changes(
+ [self.author_name_nested_deconstructible_1],
+ [self.author_name_nested_deconstructible_2],
+ )
+ self.assertEqual(changes, {})
+ # Differences that exist solely within the args list of a deconstructed object
+ # should be reported as changes
+ changes = self.get_changes(
+ [self.author_name_nested_deconstructible_1],
+ [self.author_name_nested_deconstructible_changed_arg],
+ )
+ self.assertEqual(len(changes), 1)
+ # Additional args should also be reported as a change
+ changes = self.get_changes(
+ [self.author_name_nested_deconstructible_1],
+ [self.author_name_nested_deconstructible_extra_arg],
+ )
+ self.assertEqual(len(changes), 1)
+ # Differences that exist solely within the kwargs dict of a deconstructed object
+ # should be reported as changes
+ changes = self.get_changes(
+ [self.author_name_nested_deconstructible_1],
+ [self.author_name_nested_deconstructible_changed_kwarg],
+ )
+ self.assertEqual(len(changes), 1)
+ # Additional kwargs should also be reported as a change
+ changes = self.get_changes(
+ [self.author_name_nested_deconstructible_1],
+ [self.author_name_nested_deconstructible_extra_kwarg],
+ )
+ self.assertEqual(len(changes), 1)
+
+ def test_deconstruct_type(self):
+ """
+ #22951 -- Uninstantiated classes with deconstruct are correctly returned
+ by deep_deconstruct during serialization.
+ """
+ author = ModelState(
+ "testapp",
+ "Author",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ (
+ "name",
+ models.CharField(
+ max_length=200,
+ # IntegerField intentionally not instantiated.
+ default=models.IntegerField,
+ ),
+ ),
+ ],
+ )
+ changes = self.get_changes([], [author])
+ # Right number/type of migrations?
+ self.assertNumberMigrations(changes, "testapp", 1)
+ self.assertOperationTypes(changes, "testapp", 0, ["CreateModel"])
+
+ def test_replace_string_with_foreignkey(self):
+ """
+ #22300 - Adding an FK in the same "spot" as a deleted CharField should
+ work.
+ """
+ changes = self.get_changes(
+ [self.author_with_publisher_string],
+ [self.author_with_publisher, self.publisher],
+ )
+ # Right number/type of migrations?
+ self.assertNumberMigrations(changes, "testapp", 1)
+ self.assertOperationTypes(
+ changes, "testapp", 0, ["CreateModel", "RemoveField", "AddField"]
+ )
+ self.assertOperationAttributes(changes, "testapp", 0, 0, name="Publisher")
+ self.assertOperationAttributes(changes, "testapp", 0, 1, name="publisher_name")
+ self.assertOperationAttributes(changes, "testapp", 0, 2, name="publisher")
+
+ def test_foreign_key_removed_before_target_model(self):
+ """
+ Removing an FK and the model it targets in the same change must remove
+ the FK field before the model to maintain consistency.
+ """
+ changes = self.get_changes(
+ [self.author_with_publisher, self.publisher], [self.author_name]
+ ) # removes both the model and FK
+ # Right number/type of migrations?
+ self.assertNumberMigrations(changes, "testapp", 1)
+ self.assertOperationTypes(changes, "testapp", 0, ["RemoveField", "DeleteModel"])
+ self.assertOperationAttributes(changes, "testapp", 0, 0, name="publisher")
+ self.assertOperationAttributes(changes, "testapp", 0, 1, name="Publisher")
+
+ @mock.patch(
+ "django.db.migrations.questioner.MigrationQuestioner.ask_not_null_addition",
+ side_effect=AssertionError("Should not have prompted for not null addition"),
+ )
+ def test_add_many_to_many(self, mocked_ask_method):
+ """#22435 - Adding a ManyToManyField should not prompt for a default."""
+ changes = self.get_changes(
+ [self.author_empty, self.publisher], [self.author_with_m2m, self.publisher]
+ )
+ # Right number/type of migrations?
+ self.assertNumberMigrations(changes, "testapp", 1)
+ self.assertOperationTypes(changes, "testapp", 0, ["AddField"])
+ self.assertOperationAttributes(changes, "testapp", 0, 0, name="publishers")
+
+ def test_alter_many_to_many(self):
+ changes = self.get_changes(
+ [self.author_with_m2m, self.publisher],
+ [self.author_with_m2m_blank, self.publisher],
+ )
+ # Right number/type of migrations?
+ self.assertNumberMigrations(changes, "testapp", 1)
+ self.assertOperationTypes(changes, "testapp", 0, ["AlterField"])
+ self.assertOperationAttributes(changes, "testapp", 0, 0, name="publishers")
+
+ def test_create_with_through_model(self):
+ """
+ Adding a m2m with a through model and the models that use it should be
+ ordered correctly.
+ """
+ changes = self.get_changes(
+ [], [self.author_with_m2m_through, self.publisher, self.contract]
+ )
+ # Right number/type of migrations?
+ self.assertNumberMigrations(changes, "testapp", 1)
+ self.assertOperationTypes(
+ changes,
+ "testapp",
+ 0,
+ [
+ "CreateModel",
+ "CreateModel",
+ "CreateModel",
+ "AddField",
+ ],
+ )
+ self.assertOperationAttributes(changes, "testapp", 0, 0, name="Author")
+ self.assertOperationAttributes(changes, "testapp", 0, 1, name="Publisher")
+ self.assertOperationAttributes(changes, "testapp", 0, 2, name="Contract")
+ self.assertOperationAttributes(
+ changes, "testapp", 0, 3, model_name="author", name="publishers"
+ )
+
+ def test_create_with_through_model_separate_apps(self):
+ author_with_m2m_through = ModelState(
+ "authors",
+ "Author",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ (
+ "publishers",
+ models.ManyToManyField(
+ "testapp.Publisher", through="contract.Contract"
+ ),
+ ),
+ ],
+ )
+ contract = ModelState(
+ "contract",
+ "Contract",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ("author", models.ForeignKey("authors.Author", models.CASCADE)),
+ ("publisher", models.ForeignKey("testapp.Publisher", models.CASCADE)),
+ ],
+ )
+ changes = self.get_changes(
+ [], [author_with_m2m_through, self.publisher, contract]
+ )
+ self.assertNumberMigrations(changes, "testapp", 1)
+ self.assertNumberMigrations(changes, "contract", 1)
+ self.assertNumberMigrations(changes, "authors", 2)
+ self.assertMigrationDependencies(
+ changes,
+ "authors",
+ 1,
+ {("authors", "auto_1"), ("contract", "auto_1"), ("testapp", "auto_1")},
+ )
+ self.assertOperationTypes(changes, "testapp", 0, ["CreateModel"])
+ self.assertOperationAttributes(changes, "testapp", 0, 0, name="Publisher")
+ self.assertOperationTypes(changes, "contract", 0, ["CreateModel"])
+ self.assertOperationAttributes(changes, "contract", 0, 0, name="Contract")
+ self.assertOperationTypes(changes, "authors", 0, ["CreateModel"])
+ self.assertOperationTypes(changes, "authors", 1, ["AddField"])
+ self.assertOperationAttributes(changes, "authors", 0, 0, name="Author")
+ self.assertOperationAttributes(
+ changes, "authors", 1, 0, model_name="author", name="publishers"
+ )
+
+ def test_many_to_many_removed_before_through_model(self):
+ """
+ Removing a ManyToManyField and the "through" model in the same change
+ must remove the field before the model to maintain consistency.
+ """
+ changes = self.get_changes(
+ [
+ self.book_with_multiple_authors_through_attribution,
+ self.author_name,
+ self.attribution,
+ ],
+ [self.book_with_no_author, self.author_name],
+ )
+ # Remove both the through model and ManyToMany
+ # Right number/type of migrations?
+ self.assertNumberMigrations(changes, "otherapp", 1)
+ self.assertOperationTypes(
+ changes, "otherapp", 0, ["RemoveField", "DeleteModel"]
+ )
+ self.assertOperationAttributes(
+ changes, "otherapp", 0, 0, name="authors", model_name="book"
+ )
+ self.assertOperationAttributes(changes, "otherapp", 0, 1, name="Attribution")
+
+ def test_many_to_many_removed_before_through_model_2(self):
+ """
+ Removing a model that contains a ManyToManyField and the "through" model
+ in the same change must remove the field before the model to maintain
+ consistency.
+ """
+ changes = self.get_changes(
+ [
+ self.book_with_multiple_authors_through_attribution,
+ self.author_name,
+ self.attribution,
+ ],
+ [self.author_name],
+ )
+ # Remove both the through model and ManyToMany
+ # Right number/type of migrations?
+ self.assertNumberMigrations(changes, "otherapp", 1)
+ self.assertOperationTypes(
+ changes, "otherapp", 0, ["RemoveField", "DeleteModel", "DeleteModel"]
+ )
+ self.assertOperationAttributes(
+ changes, "otherapp", 0, 0, name="authors", model_name="book"
+ )
+ self.assertOperationAttributes(changes, "otherapp", 0, 1, name="Attribution")
+ self.assertOperationAttributes(changes, "otherapp", 0, 2, name="Book")
+
+ def test_m2m_w_through_multistep_remove(self):
+ """
+ A model with a m2m field that specifies a "through" model cannot be
+ removed in the same migration as that through model as the schema will
+ pass through an inconsistent state. The autodetector should produce two
+ migrations to avoid this issue.
+ """
+ changes = self.get_changes(
+ [self.author_with_m2m_through, self.publisher, self.contract],
+ [self.publisher],
+ )
+ # Right number/type of migrations?
+ self.assertNumberMigrations(changes, "testapp", 1)
+ self.assertOperationTypes(
+ changes,
+ "testapp",
+ 0,
+ ["RemoveField", "RemoveField", "DeleteModel", "DeleteModel"],
+ )
+ self.assertOperationAttributes(
+ changes, "testapp", 0, 0, name="author", model_name="contract"
+ )
+ self.assertOperationAttributes(
+ changes, "testapp", 0, 1, name="publisher", model_name="contract"
+ )
+ self.assertOperationAttributes(changes, "testapp", 0, 2, name="Author")
+ self.assertOperationAttributes(changes, "testapp", 0, 3, name="Contract")
+
+ def test_concrete_field_changed_to_many_to_many(self):
+ """
+ #23938 - Changing a concrete field into a ManyToManyField
+ first removes the concrete field and then adds the m2m field.
+ """
+ changes = self.get_changes(
+ [self.author_with_former_m2m], [self.author_with_m2m, self.publisher]
+ )
+ # Right number/type of migrations?
+ self.assertNumberMigrations(changes, "testapp", 1)
+ self.assertOperationTypes(
+ changes, "testapp", 0, ["CreateModel", "RemoveField", "AddField"]
+ )
+ self.assertOperationAttributes(changes, "testapp", 0, 0, name="Publisher")
+ self.assertOperationAttributes(
+ changes, "testapp", 0, 1, name="publishers", model_name="author"
+ )
+ self.assertOperationAttributes(
+ changes, "testapp", 0, 2, name="publishers", model_name="author"
+ )
+
+ def test_many_to_many_changed_to_concrete_field(self):
+ """
+ #23938 - Changing a ManyToManyField into a concrete field
+ first removes the m2m field and then adds the concrete field.
+ """
+ changes = self.get_changes(
+ [self.author_with_m2m, self.publisher], [self.author_with_former_m2m]
+ )
+ # Right number/type of migrations?
+ self.assertNumberMigrations(changes, "testapp", 1)
+ self.assertOperationTypes(
+ changes, "testapp", 0, ["RemoveField", "DeleteModel", "AddField"]
+ )
+ self.assertOperationAttributes(
+ changes, "testapp", 0, 0, name="publishers", model_name="author"
+ )
+ self.assertOperationAttributes(changes, "testapp", 0, 1, name="Publisher")
+ self.assertOperationAttributes(
+ changes, "testapp", 0, 2, name="publishers", model_name="author"
+ )
+ self.assertOperationFieldAttributes(changes, "testapp", 0, 2, max_length=100)
+
+ def test_non_circular_foreignkey_dependency_removal(self):
+ """
+ If two models with a ForeignKey from one to the other are removed at the
+ same time, the autodetector should remove them in the correct order.
+ """
+ changes = self.get_changes(
+ [self.author_with_publisher, self.publisher_with_author], []
+ )
+ # Right number/type of migrations?
+ self.assertNumberMigrations(changes, "testapp", 1)
+ self.assertOperationTypes(
+ changes, "testapp", 0, ["RemoveField", "DeleteModel", "DeleteModel"]
+ )
+ self.assertOperationAttributes(
+ changes, "testapp", 0, 0, name="author", model_name="publisher"
+ )
+ self.assertOperationAttributes(changes, "testapp", 0, 1, name="Author")
+ self.assertOperationAttributes(changes, "testapp", 0, 2, name="Publisher")
+
+ def test_alter_model_options(self):
+ """Changing a model's options should make a change."""
+ changes = self.get_changes([self.author_empty], [self.author_with_options])
+ # Right number/type of migrations?
+ self.assertNumberMigrations(changes, "testapp", 1)
+ self.assertOperationTypes(changes, "testapp", 0, ["AlterModelOptions"])
+ self.assertOperationAttributes(
+ changes,
+ "testapp",
+ 0,
+ 0,
+ options={
+ "permissions": [("can_hire", "Can hire")],
+ "verbose_name": "Authi",
+ },
+ )
+
+ # Changing them back to empty should also make a change
+ changes = self.get_changes([self.author_with_options], [self.author_empty])
+ # Right number/type of migrations?
+ self.assertNumberMigrations(changes, "testapp", 1)
+ self.assertOperationTypes(changes, "testapp", 0, ["AlterModelOptions"])
+ self.assertOperationAttributes(
+ changes, "testapp", 0, 0, name="author", options={}
+ )
+
+ def test_alter_model_options_proxy(self):
+ """Changing a proxy model's options should also make a change."""
+ changes = self.get_changes(
+ [self.author_proxy, self.author_empty],
+ [self.author_proxy_options, self.author_empty],
+ )
+ # Right number/type of migrations?
+ self.assertNumberMigrations(changes, "testapp", 1)
+ self.assertOperationTypes(changes, "testapp", 0, ["AlterModelOptions"])
+ self.assertOperationAttributes(
+ changes,
+ "testapp",
+ 0,
+ 0,
+ name="authorproxy",
+ options={"verbose_name": "Super Author"},
+ )
+
+ def test_set_alter_order_with_respect_to(self):
+ """Setting order_with_respect_to adds a field."""
+ changes = self.get_changes(
+ [self.book, self.author_with_book],
+ [self.book, self.author_with_book_order_wrt],
+ )
+ # Right number/type of migrations?
+ self.assertNumberMigrations(changes, "testapp", 1)
+ self.assertOperationTypes(changes, "testapp", 0, ["AlterOrderWithRespectTo"])
+ self.assertOperationAttributes(
+ changes, "testapp", 0, 0, name="author", order_with_respect_to="book"
+ )
+
+ def test_add_alter_order_with_respect_to(self):
+ """
+ Setting order_with_respect_to when adding the FK too does
+ things in the right order.
+ """
+ changes = self.get_changes(
+ [self.author_name], [self.book, self.author_with_book_order_wrt]
+ )
+ # Right number/type of migrations?
+ self.assertNumberMigrations(changes, "testapp", 1)
+ self.assertOperationTypes(
+ changes, "testapp", 0, ["AddField", "AlterOrderWithRespectTo"]
+ )
+ self.assertOperationAttributes(
+ changes, "testapp", 0, 0, model_name="author", name="book"
+ )
+ self.assertOperationAttributes(
+ changes, "testapp", 0, 1, name="author", order_with_respect_to="book"
+ )
+
+ def test_remove_alter_order_with_respect_to(self):
+ """
+ Removing order_with_respect_to when removing the FK too does
+ things in the right order.
+ """
+ changes = self.get_changes(
+ [self.book, self.author_with_book_order_wrt], [self.author_name]
+ )
+ # Right number/type of migrations?
+ self.assertNumberMigrations(changes, "testapp", 1)
+ self.assertOperationTypes(
+ changes, "testapp", 0, ["AlterOrderWithRespectTo", "RemoveField"]
+ )
+ self.assertOperationAttributes(
+ changes, "testapp", 0, 0, name="author", order_with_respect_to=None
+ )
+ self.assertOperationAttributes(
+ changes, "testapp", 0, 1, model_name="author", name="book"
+ )
+
+ def test_add_model_order_with_respect_to(self):
+ """
+ Setting order_with_respect_to when adding the whole model
+ does things in the right order.
+ """
+ changes = self.get_changes([], [self.book, self.author_with_book_order_wrt])
+ # Right number/type of migrations?
+ self.assertNumberMigrations(changes, "testapp", 1)
+ self.assertOperationTypes(changes, "testapp", 0, ["CreateModel"])
+ self.assertOperationAttributes(
+ changes,
+ "testapp",
+ 0,
+ 0,
+ name="Author",
+ options={"order_with_respect_to": "book"},
+ )
+ self.assertNotIn(
+ "_order",
+ [name for name, field in changes["testapp"][0].operations[0].fields],
+ )
+
+ def test_add_model_order_with_respect_to_unique_together(self):
+ changes = self.get_changes(
+ [],
+ [
+ self.book,
+ ModelState(
+ "testapp",
+ "Author",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ("name", models.CharField(max_length=200)),
+ ("book", models.ForeignKey("otherapp.Book", models.CASCADE)),
+ ],
+ options={
+ "order_with_respect_to": "book",
+ "unique_together": {("id", "_order")},
+ },
+ ),
+ ],
+ )
+ self.assertNumberMigrations(changes, "testapp", 1)
+ self.assertOperationTypes(changes, "testapp", 0, ["CreateModel"])
+ self.assertOperationAttributes(
+ changes,
+ "testapp",
+ 0,
+ 0,
+ name="Author",
+ options={
+ "order_with_respect_to": "book",
+ "unique_together": {("id", "_order")},
+ },
+ )
+
+ def test_add_model_order_with_respect_to_constraint(self):
+ after = ModelState(
+ "testapp",
+ "Author",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ("name", models.CharField(max_length=200)),
+ ("book", models.ForeignKey("otherapp.Book", models.CASCADE)),
+ ],
+ options={
+ "order_with_respect_to": "book",
+ "constraints": [
+ models.CheckConstraint(
+ check=models.Q(_order__gt=1), name="book_order_gt_1"
+ ),
+ ],
+ },
+ )
+ changes = self.get_changes([], [self.book, after])
+ self.assertNumberMigrations(changes, "testapp", 1)
+ self.assertOperationTypes(
+ changes,
+ "testapp",
+ 0,
+ ["CreateModel", "AddConstraint"],
+ )
+ self.assertOperationAttributes(
+ changes,
+ "testapp",
+ 0,
+ 0,
+ name="Author",
+ options={"order_with_respect_to": "book"},
+ )
+
+ def test_add_model_order_with_respect_to_index(self):
+ after = ModelState(
+ "testapp",
+ "Author",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ("name", models.CharField(max_length=200)),
+ ("book", models.ForeignKey("otherapp.Book", models.CASCADE)),
+ ],
+ options={
+ "order_with_respect_to": "book",
+ "indexes": [models.Index(fields=["_order"], name="book_order_idx")],
+ },
+ )
+ changes = self.get_changes([], [self.book, after])
+ self.assertNumberMigrations(changes, "testapp", 1)
+ self.assertOperationTypes(changes, "testapp", 0, ["CreateModel"])
+ self.assertOperationAttributes(
+ changes,
+ "testapp",
+ 0,
+ 0,
+ name="Author",
+ options={
+ "order_with_respect_to": "book",
+ "indexes": [models.Index(fields=["_order"], name="book_order_idx")],
+ },
+ )
+
+ def test_set_alter_order_with_respect_to_index_constraint_unique_together(self):
+ tests = [
+ (
+ "AddIndex",
+ {
+ "indexes": [
+ models.Index(fields=["_order"], name="book_order_idx"),
+ ]
+ },
+ ),
+ (
+ "AddConstraint",
+ {
+ "constraints": [
+ models.CheckConstraint(
+ check=models.Q(_order__gt=1),
+ name="book_order_gt_1",
+ ),
+ ]
+ },
+ ),
+ ("AlterUniqueTogether", {"unique_together": {("id", "_order")}}),
+ ]
+ for operation, extra_option in tests:
+ with self.subTest(operation=operation):
+ after = ModelState(
+ "testapp",
+ "Author",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ("name", models.CharField(max_length=200)),
+ ("book", models.ForeignKey("otherapp.Book", models.CASCADE)),
+ ],
+ options={
+ "order_with_respect_to": "book",
+ **extra_option,
+ },
+ )
+ changes = self.get_changes(
+ [self.book, self.author_with_book],
+ [self.book, after],
+ )
+ self.assertNumberMigrations(changes, "testapp", 1)
+ self.assertOperationTypes(
+ changes,
+ "testapp",
+ 0,
+ [
+ "AlterOrderWithRespectTo",
+ operation,
+ ],
+ )
+
+ def test_alter_model_managers(self):
+ """
+ Changing the model managers adds a new operation.
+ """
+ changes = self.get_changes([self.other_pony], [self.other_pony_food])
+ # Right number/type of migrations?
+ self.assertNumberMigrations(changes, "otherapp", 1)
+ self.assertOperationTypes(changes, "otherapp", 0, ["AlterModelManagers"])
+ self.assertOperationAttributes(changes, "otherapp", 0, 0, name="pony")
+ self.assertEqual(
+ [name for name, mgr in changes["otherapp"][0].operations[0].managers],
+ ["food_qs", "food_mgr", "food_mgr_kwargs"],
+ )
+ self.assertEqual(
+ changes["otherapp"][0].operations[0].managers[1][1].args, ("a", "b", 1, 2)
+ )
+ self.assertEqual(
+ changes["otherapp"][0].operations[0].managers[2][1].args, ("x", "y", 3, 4)
+ )
+
+ def test_swappable_first_inheritance(self):
+ """Swappable models get their CreateModel first."""
+ changes = self.get_changes([], [self.custom_user, self.aardvark])
+ # Right number/type of migrations?
+ self.assertNumberMigrations(changes, "thirdapp", 1)
+ self.assertOperationTypes(
+ changes, "thirdapp", 0, ["CreateModel", "CreateModel"]
+ )
+ self.assertOperationAttributes(changes, "thirdapp", 0, 0, name="CustomUser")
+ self.assertOperationAttributes(changes, "thirdapp", 0, 1, name="Aardvark")
+
+ def test_default_related_name_option(self):
+ model_state = ModelState(
+ "app",
+ "model",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ],
+ options={"default_related_name": "related_name"},
+ )
+ changes = self.get_changes([], [model_state])
+ self.assertNumberMigrations(changes, "app", 1)
+ self.assertOperationTypes(changes, "app", 0, ["CreateModel"])
+ self.assertOperationAttributes(
+ changes,
+ "app",
+ 0,
+ 0,
+ name="model",
+ options={"default_related_name": "related_name"},
+ )
+ altered_model_state = ModelState(
+ "app",
+ "Model",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ],
+ )
+ changes = self.get_changes([model_state], [altered_model_state])
+ self.assertNumberMigrations(changes, "app", 1)
+ self.assertOperationTypes(changes, "app", 0, ["AlterModelOptions"])
+ self.assertOperationAttributes(changes, "app", 0, 0, name="model", options={})
+
+ @override_settings(AUTH_USER_MODEL="thirdapp.CustomUser")
+ def test_swappable_first_setting(self):
+ """Swappable models get their CreateModel first."""
+ with isolate_lru_cache(apps.get_swappable_settings_name):
+ changes = self.get_changes([], [self.custom_user_no_inherit, self.aardvark])
+ # Right number/type of migrations?
+ self.assertNumberMigrations(changes, "thirdapp", 1)
+ self.assertOperationTypes(
+ changes, "thirdapp", 0, ["CreateModel", "CreateModel"]
+ )
+ self.assertOperationAttributes(changes, "thirdapp", 0, 0, name="CustomUser")
+ self.assertOperationAttributes(changes, "thirdapp", 0, 1, name="Aardvark")
+
+ def test_bases_first(self):
+ """Bases of other models come first."""
+ changes = self.get_changes(
+ [], [self.aardvark_based_on_author, self.author_name]
+ )
+ # Right number/type of migrations?
+ self.assertNumberMigrations(changes, "testapp", 1)
+ self.assertOperationTypes(changes, "testapp", 0, ["CreateModel", "CreateModel"])
+ self.assertOperationAttributes(changes, "testapp", 0, 0, name="Author")
+ self.assertOperationAttributes(changes, "testapp", 0, 1, name="Aardvark")
+
+ def test_bases_first_mixed_case_app_label(self):
+ app_label = "MiXedCaseApp"
+ changes = self.get_changes(
+ [],
+ [
+ ModelState(
+ app_label,
+ "owner",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ],
+ ),
+ ModelState(
+ app_label,
+ "place",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ (
+ "owner",
+ models.ForeignKey("MiXedCaseApp.owner", models.CASCADE),
+ ),
+ ],
+ ),
+ ModelState(app_label, "restaurant", [], bases=("MiXedCaseApp.place",)),
+ ],
+ )
+ self.assertNumberMigrations(changes, app_label, 1)
+ self.assertOperationTypes(
+ changes,
+ app_label,
+ 0,
+ [
+ "CreateModel",
+ "CreateModel",
+ "CreateModel",
+ ],
+ )
+ self.assertOperationAttributes(changes, app_label, 0, 0, name="owner")
+ self.assertOperationAttributes(changes, app_label, 0, 1, name="place")
+ self.assertOperationAttributes(changes, app_label, 0, 2, name="restaurant")
+
+ def test_multiple_bases(self):
+ """
+ Inheriting models doesn't move *_ptr fields into AddField operations.
+ """
+ A = ModelState("app", "A", [("a_id", models.AutoField(primary_key=True))])
+ B = ModelState("app", "B", [("b_id", models.AutoField(primary_key=True))])
+ C = ModelState("app", "C", [], bases=("app.A", "app.B"))
+ D = ModelState("app", "D", [], bases=("app.A", "app.B"))
+ E = ModelState("app", "E", [], bases=("app.A", "app.B"))
+ changes = self.get_changes([], [A, B, C, D, E])
+ # Right number/type of migrations?
+ self.assertNumberMigrations(changes, "app", 1)
+ self.assertOperationTypes(
+ changes,
+ "app",
+ 0,
+ ["CreateModel", "CreateModel", "CreateModel", "CreateModel", "CreateModel"],
+ )
+ self.assertOperationAttributes(changes, "app", 0, 0, name="A")
+ self.assertOperationAttributes(changes, "app", 0, 1, name="B")
+ self.assertOperationAttributes(changes, "app", 0, 2, name="C")
+ self.assertOperationAttributes(changes, "app", 0, 3, name="D")
+ self.assertOperationAttributes(changes, "app", 0, 4, name="E")
+
+ def test_proxy_bases_first(self):
+ """Bases of proxies come first."""
+ changes = self.get_changes(
+ [], [self.author_empty, self.author_proxy, self.author_proxy_proxy]
+ )
+ # Right number/type of migrations?
+ self.assertNumberMigrations(changes, "testapp", 1)
+ self.assertOperationTypes(
+ changes, "testapp", 0, ["CreateModel", "CreateModel", "CreateModel"]
+ )
+ self.assertOperationAttributes(changes, "testapp", 0, 0, name="Author")
+ self.assertOperationAttributes(changes, "testapp", 0, 1, name="AuthorProxy")
+ self.assertOperationAttributes(
+ changes, "testapp", 0, 2, name="AAuthorProxyProxy"
+ )
+
+ def test_pk_fk_included(self):
+ """
+ A relation used as the primary key is kept as part of CreateModel.
+ """
+ changes = self.get_changes([], [self.aardvark_pk_fk_author, self.author_name])
+ # Right number/type of migrations?
+ self.assertNumberMigrations(changes, "testapp", 1)
+ self.assertOperationTypes(changes, "testapp", 0, ["CreateModel", "CreateModel"])
+ self.assertOperationAttributes(changes, "testapp", 0, 0, name="Author")
+ self.assertOperationAttributes(changes, "testapp", 0, 1, name="Aardvark")
+
+ def test_first_dependency(self):
+ """
+ A dependency to an app with no migrations uses __first__.
+ """
+ # Load graph
+ loader = MigrationLoader(connection)
+ before = self.make_project_state([])
+ after = self.make_project_state([self.book_migrations_fk])
+ after.real_apps = {"migrations"}
+ autodetector = MigrationAutodetector(before, after)
+ changes = autodetector._detect_changes(graph=loader.graph)
+ # Right number/type of migrations?
+ self.assertNumberMigrations(changes, "otherapp", 1)
+ self.assertOperationTypes(changes, "otherapp", 0, ["CreateModel"])
+ self.assertOperationAttributes(changes, "otherapp", 0, 0, name="Book")
+ self.assertMigrationDependencies(
+ changes, "otherapp", 0, [("migrations", "__first__")]
+ )
+
+ @override_settings(MIGRATION_MODULES={"migrations": "migrations.test_migrations"})
+ def test_last_dependency(self):
+ """
+ A dependency to an app with existing migrations uses the
+ last migration of that app.
+ """
+ # Load graph
+ loader = MigrationLoader(connection)
+ before = self.make_project_state([])
+ after = self.make_project_state([self.book_migrations_fk])
+ after.real_apps = {"migrations"}
+ autodetector = MigrationAutodetector(before, after)
+ changes = autodetector._detect_changes(graph=loader.graph)
+ # Right number/type of migrations?
+ self.assertNumberMigrations(changes, "otherapp", 1)
+ self.assertOperationTypes(changes, "otherapp", 0, ["CreateModel"])
+ self.assertOperationAttributes(changes, "otherapp", 0, 0, name="Book")
+ self.assertMigrationDependencies(
+ changes, "otherapp", 0, [("migrations", "0002_second")]
+ )
+
+ def test_alter_fk_before_model_deletion(self):
+ """
+ ForeignKeys are altered _before_ the model they used to
+ refer to are deleted.
+ """
+ changes = self.get_changes(
+ [self.author_name, self.publisher_with_author],
+ [self.aardvark_testapp, self.publisher_with_aardvark_author],
+ )
+ # Right number/type of migrations?
+ self.assertNumberMigrations(changes, "testapp", 1)
+ self.assertOperationTypes(
+ changes, "testapp", 0, ["CreateModel", "AlterField", "DeleteModel"]
+ )
+ self.assertOperationAttributes(changes, "testapp", 0, 0, name="Aardvark")
+ self.assertOperationAttributes(changes, "testapp", 0, 1, name="author")
+ self.assertOperationAttributes(changes, "testapp", 0, 2, name="Author")
+
+ def test_fk_dependency_other_app(self):
+ """
+ #23100 - ForeignKeys correctly depend on other apps' models.
+ """
+ changes = self.get_changes(
+ [self.author_name, self.book], [self.author_with_book, self.book]
+ )
+ # Right number/type of migrations?
+ self.assertNumberMigrations(changes, "testapp", 1)
+ self.assertOperationTypes(changes, "testapp", 0, ["AddField"])
+ self.assertOperationAttributes(changes, "testapp", 0, 0, name="book")
+ self.assertMigrationDependencies(
+ changes, "testapp", 0, [("otherapp", "__first__")]
+ )
+
+ def test_alter_unique_together_fk_to_m2m(self):
+ changes = self.get_changes(
+ [self.author_name, self.book_unique_together],
+ [
+ self.author_name,
+ ModelState(
+ "otherapp",
+ "Book",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ("author", models.ManyToManyField("testapp.Author")),
+ ("title", models.CharField(max_length=200)),
+ ],
+ ),
+ ],
+ )
+ self.assertNumberMigrations(changes, "otherapp", 1)
+ self.assertOperationTypes(
+ changes, "otherapp", 0, ["AlterUniqueTogether", "RemoveField", "AddField"]
+ )
+ self.assertOperationAttributes(
+ changes, "otherapp", 0, 0, name="book", unique_together=set()
+ )
+ self.assertOperationAttributes(
+ changes, "otherapp", 0, 1, model_name="book", name="author"
+ )
+ self.assertOperationAttributes(
+ changes, "otherapp", 0, 2, model_name="book", name="author"
+ )
+
+ def test_alter_field_to_fk_dependency_other_app(self):
+ changes = self.get_changes(
+ [self.author_empty, self.book_with_no_author_fk],
+ [self.author_empty, self.book],
+ )
+ self.assertNumberMigrations(changes, "otherapp", 1)
+ self.assertOperationTypes(changes, "otherapp", 0, ["AlterField"])
+ self.assertMigrationDependencies(
+ changes, "otherapp", 0, [("testapp", "__first__")]
+ )
+
+ def test_circular_dependency_mixed_addcreate(self):
+ """
+ #23315 - The dependency resolver knows to put all CreateModel
+ before AddField and not become unsolvable.
+ """
+ address = ModelState(
+ "a",
+ "Address",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ("country", models.ForeignKey("b.DeliveryCountry", models.CASCADE)),
+ ],
+ )
+ person = ModelState(
+ "a",
+ "Person",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ],
+ )
+ apackage = ModelState(
+ "b",
+ "APackage",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ("person", models.ForeignKey("a.Person", models.CASCADE)),
+ ],
+ )
+ country = ModelState(
+ "b",
+ "DeliveryCountry",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ],
+ )
+ changes = self.get_changes([], [address, person, apackage, country])
+ # Right number/type of migrations?
+ self.assertNumberMigrations(changes, "a", 2)
+ self.assertNumberMigrations(changes, "b", 1)
+ self.assertOperationTypes(changes, "a", 0, ["CreateModel", "CreateModel"])
+ self.assertOperationTypes(changes, "a", 1, ["AddField"])
+ self.assertOperationTypes(changes, "b", 0, ["CreateModel", "CreateModel"])
+
+ @override_settings(AUTH_USER_MODEL="a.Tenant")
+ def test_circular_dependency_swappable(self):
+ """
+ #23322 - The dependency resolver knows to explicitly resolve
+ swappable models.
+ """
+ with isolate_lru_cache(apps.get_swappable_settings_name):
+ tenant = ModelState(
+ "a",
+ "Tenant",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ("primary_address", models.ForeignKey("b.Address", models.CASCADE)),
+ ],
+ bases=(AbstractBaseUser,),
+ )
+ address = ModelState(
+ "b",
+ "Address",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ (
+ "tenant",
+ models.ForeignKey(settings.AUTH_USER_MODEL, models.CASCADE),
+ ),
+ ],
+ )
+ changes = self.get_changes([], [address, tenant])
+
+ # Right number/type of migrations?
+ self.assertNumberMigrations(changes, "a", 2)
+ self.assertOperationTypes(changes, "a", 0, ["CreateModel"])
+ self.assertOperationTypes(changes, "a", 1, ["AddField"])
+ self.assertMigrationDependencies(changes, "a", 0, [])
+ self.assertMigrationDependencies(
+ changes, "a", 1, [("a", "auto_1"), ("b", "auto_1")]
+ )
+ # Right number/type of migrations?
+ self.assertNumberMigrations(changes, "b", 1)
+ self.assertOperationTypes(changes, "b", 0, ["CreateModel"])
+ self.assertMigrationDependencies(
+ changes, "b", 0, [("__setting__", "AUTH_USER_MODEL")]
+ )
+
+ @override_settings(AUTH_USER_MODEL="b.Tenant")
+ def test_circular_dependency_swappable2(self):
+ """
+ #23322 - The dependency resolver knows to explicitly resolve
+ swappable models but with the swappable not being the first migrated
+ model.
+ """
+ with isolate_lru_cache(apps.get_swappable_settings_name):
+ address = ModelState(
+ "a",
+ "Address",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ (
+ "tenant",
+ models.ForeignKey(settings.AUTH_USER_MODEL, models.CASCADE),
+ ),
+ ],
+ )
+ tenant = ModelState(
+ "b",
+ "Tenant",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ("primary_address", models.ForeignKey("a.Address", models.CASCADE)),
+ ],
+ bases=(AbstractBaseUser,),
+ )
+ changes = self.get_changes([], [address, tenant])
+ # Right number/type of migrations?
+ self.assertNumberMigrations(changes, "a", 2)
+ self.assertOperationTypes(changes, "a", 0, ["CreateModel"])
+ self.assertOperationTypes(changes, "a", 1, ["AddField"])
+ self.assertMigrationDependencies(changes, "a", 0, [])
+ self.assertMigrationDependencies(
+ changes, "a", 1, [("__setting__", "AUTH_USER_MODEL"), ("a", "auto_1")]
+ )
+ # Right number/type of migrations?
+ self.assertNumberMigrations(changes, "b", 1)
+ self.assertOperationTypes(changes, "b", 0, ["CreateModel"])
+ self.assertMigrationDependencies(changes, "b", 0, [("a", "auto_1")])
+
+ @override_settings(AUTH_USER_MODEL="a.Person")
+ def test_circular_dependency_swappable_self(self):
+ """
+ #23322 - The dependency resolver knows to explicitly resolve
+ swappable models.
+ """
+ with isolate_lru_cache(apps.get_swappable_settings_name):
+ person = ModelState(
+ "a",
+ "Person",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ (
+ "parent1",
+ models.ForeignKey(
+ settings.AUTH_USER_MODEL,
+ models.CASCADE,
+ related_name="children",
+ ),
+ ),
+ ],
+ )
+ changes = self.get_changes([], [person])
+ # Right number/type of migrations?
+ self.assertNumberMigrations(changes, "a", 1)
+ self.assertOperationTypes(changes, "a", 0, ["CreateModel"])
+ self.assertMigrationDependencies(changes, "a", 0, [])
+
+ @override_settings(AUTH_USER_MODEL="a.User")
+ def test_swappable_circular_multi_mti(self):
+ with isolate_lru_cache(apps.get_swappable_settings_name):
+ parent = ModelState(
+ "a",
+ "Parent",
+ [("user", models.ForeignKey(settings.AUTH_USER_MODEL, models.CASCADE))],
+ )
+ child = ModelState("a", "Child", [], bases=("a.Parent",))
+ user = ModelState("a", "User", [], bases=(AbstractBaseUser, "a.Child"))
+ changes = self.get_changes([], [parent, child, user])
+ self.assertNumberMigrations(changes, "a", 1)
+ self.assertOperationTypes(
+ changes, "a", 0, ["CreateModel", "CreateModel", "CreateModel", "AddField"]
+ )
+
+ @mock.patch(
+ "django.db.migrations.questioner.MigrationQuestioner.ask_not_null_addition",
+ side_effect=AssertionError("Should not have prompted for not null addition"),
+ )
+ def test_add_blank_textfield_and_charfield(self, mocked_ask_method):
+ """
+ #23405 - Adding a NOT NULL and blank `CharField` or `TextField`
+ without default should not prompt for a default.
+ """
+ changes = self.get_changes(
+ [self.author_empty], [self.author_with_biography_blank]
+ )
+ # Right number/type of migrations?
+ self.assertNumberMigrations(changes, "testapp", 1)
+ self.assertOperationTypes(changes, "testapp", 0, ["AddField", "AddField"])
+ self.assertOperationAttributes(changes, "testapp", 0, 0)
+
+ @mock.patch(
+ "django.db.migrations.questioner.MigrationQuestioner.ask_not_null_addition"
+ )
+ def test_add_non_blank_textfield_and_charfield(self, mocked_ask_method):
+ """
+ #23405 - Adding a NOT NULL and non-blank `CharField` or `TextField`
+ without default should prompt for a default.
+ """
+ changes = self.get_changes(
+ [self.author_empty], [self.author_with_biography_non_blank]
+ )
+ self.assertEqual(mocked_ask_method.call_count, 2)
+ # Right number/type of migrations?
+ self.assertNumberMigrations(changes, "testapp", 1)
+ self.assertOperationTypes(changes, "testapp", 0, ["AddField", "AddField"])
+ self.assertOperationAttributes(changes, "testapp", 0, 0)
+
+ def test_mti_inheritance_model_removal(self):
+ Animal = ModelState(
+ "app",
+ "Animal",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ],
+ )
+ Dog = ModelState("app", "Dog", [], bases=("app.Animal",))
+ changes = self.get_changes([Animal, Dog], [Animal])
+ self.assertNumberMigrations(changes, "app", 1)
+ self.assertOperationTypes(changes, "app", 0, ["DeleteModel"])
+ self.assertOperationAttributes(changes, "app", 0, 0, name="Dog")
+
+ def test_add_model_with_field_removed_from_base_model(self):
+ """
+ Removing a base field takes place before adding a new inherited model
+ that has a field with the same name.
+ """
+ before = [
+ ModelState(
+ "app",
+ "readable",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ("title", models.CharField(max_length=200)),
+ ],
+ ),
+ ]
+ after = [
+ ModelState(
+ "app",
+ "readable",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ],
+ ),
+ ModelState(
+ "app",
+ "book",
+ [
+ ("title", models.CharField(max_length=200)),
+ ],
+ bases=("app.readable",),
+ ),
+ ]
+ changes = self.get_changes(before, after)
+ self.assertNumberMigrations(changes, "app", 1)
+ self.assertOperationTypes(changes, "app", 0, ["RemoveField", "CreateModel"])
+ self.assertOperationAttributes(
+ changes, "app", 0, 0, name="title", model_name="readable"
+ )
+ self.assertOperationAttributes(changes, "app", 0, 1, name="book")
+
+ def test_parse_number(self):
+ tests = [
+ ("no_number", None),
+ ("0001_initial", 1),
+ ("0002_model3", 2),
+ ("0002_auto_20380101_1112", 2),
+ ("0002_squashed_0003", 3),
+ ("0002_model2_squashed_0003_other4", 3),
+ ("0002_squashed_0003_squashed_0004", 4),
+ ("0002_model2_squashed_0003_other4_squashed_0005_other6", 5),
+ ("0002_custom_name_20380101_1112_squashed_0003_model", 3),
+ ("2_squashed_4", 4),
+ ]
+ for migration_name, expected_number in tests:
+ with self.subTest(migration_name=migration_name):
+ self.assertEqual(
+ MigrationAutodetector.parse_number(migration_name),
+ expected_number,
+ )
+
+ def test_add_custom_fk_with_hardcoded_to(self):
+ class HardcodedForeignKey(models.ForeignKey):
+ def __init__(self, *args, **kwargs):
+ kwargs["to"] = "testapp.Author"
+ super().__init__(*args, **kwargs)
+
+ def deconstruct(self):
+ name, path, args, kwargs = super().deconstruct()
+ del kwargs["to"]
+ return name, path, args, kwargs
+
+ book_hardcoded_fk_to = ModelState(
+ "testapp",
+ "Book",
+ [
+ ("author", HardcodedForeignKey(on_delete=models.CASCADE)),
+ ],
+ )
+ changes = self.get_changes(
+ [self.author_empty],
+ [self.author_empty, book_hardcoded_fk_to],
+ )
+ self.assertNumberMigrations(changes, "testapp", 1)
+ self.assertOperationTypes(changes, "testapp", 0, ["CreateModel"])
+ self.assertOperationAttributes(changes, "testapp", 0, 0, name="Book")
+
+
+@ignore_warnings(category=RemovedInDjango51Warning)
+class AutodetectorIndexTogetherTests(BaseAutodetectorTests):
+ book_index_together = ModelState(
+ "otherapp",
+ "Book",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ("author", models.ForeignKey("testapp.Author", models.CASCADE)),
+ ("title", models.CharField(max_length=200)),
+ ],
+ {
+ "index_together": {("author", "title")},
+ },
+ )
+ book_index_together_2 = ModelState(
+ "otherapp",
+ "Book",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ("author", models.ForeignKey("testapp.Author", models.CASCADE)),
+ ("title", models.CharField(max_length=200)),
+ ],
+ {
+ "index_together": {("title", "author")},
+ },
+ )
+ book_index_together_3 = ModelState(
+ "otherapp",
+ "Book",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ("newfield", models.IntegerField()),
+ ("author", models.ForeignKey("testapp.Author", models.CASCADE)),
+ ("title", models.CharField(max_length=200)),
+ ],
+ {
+ "index_together": {("title", "newfield")},
+ },
+ )
+ book_index_together_4 = ModelState(
+ "otherapp",
+ "Book",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ("newfield2", models.IntegerField()),
+ ("author", models.ForeignKey("testapp.Author", models.CASCADE)),
+ ("title", models.CharField(max_length=200)),
+ ],
+ {
+ "index_together": {("title", "newfield2")},
+ },
+ )
+
+ def test_empty_index_together(self):
+ """Empty index_together shouldn't generate a migration."""
+ # Explicitly testing for not specified, since this is the case after
+ # a CreateModel operation w/o any definition on the original model
+ model_state_not_specified = ModelState(
+ "a", "model", [("id", models.AutoField(primary_key=True))]
+ )
+ # Explicitly testing for None, since this was the issue in #23452 after
+ # an AlterIndexTogether operation with e.g. () as value
+ model_state_none = ModelState(
+ "a",
+ "model",
+ [("id", models.AutoField(primary_key=True))],
+ {
+ "index_together": None,
+ },
+ )
+ # Explicitly testing for the empty set, since we now always have sets.
+ # During removal (('col1', 'col2'),) --> () this becomes set([])
+ model_state_empty = ModelState(
+ "a",
+ "model",
+ [("id", models.AutoField(primary_key=True))],
+ {
+ "index_together": set(),
+ },
+ )
+
+ def test(from_state, to_state, msg):
+ changes = self.get_changes([from_state], [to_state])
+ if changes:
+ ops = ", ".join(
+ o.__class__.__name__ for o in changes["a"][0].operations
+ )
+ self.fail("Created operation(s) %s from %s" % (ops, msg))
+
+ tests = (
+ (
+ model_state_not_specified,
+ model_state_not_specified,
+ '"not specified" to "not specified"',
+ ),
+ (model_state_not_specified, model_state_none, '"not specified" to "None"'),
+ (
+ model_state_not_specified,
+ model_state_empty,
+ '"not specified" to "empty"',
+ ),
+ (model_state_none, model_state_not_specified, '"None" to "not specified"'),
+ (model_state_none, model_state_none, '"None" to "None"'),
+ (model_state_none, model_state_empty, '"None" to "empty"'),
+ (
+ model_state_empty,
+ model_state_not_specified,
+ '"empty" to "not specified"',
+ ),
+ (model_state_empty, model_state_none, '"empty" to "None"'),
+ (model_state_empty, model_state_empty, '"empty" to "empty"'),
+ )
+
+ for t in tests:
+ test(*t)
+
+ def test_rename_index_together_to_index(self):
+ changes = self.get_changes(
+ [AutodetectorTests.author_empty, self.book_index_together],
+ [AutodetectorTests.author_empty, AutodetectorTests.book_indexes],
+ )
+ self.assertNumberMigrations(changes, "otherapp", 1)
+ self.assertOperationTypes(changes, "otherapp", 0, ["RenameIndex"])
+ self.assertOperationAttributes(
+ changes,
+ "otherapp",
+ 0,
+ 0,
+ model_name="book",
+ new_name="book_title_author_idx",
+ old_fields=("author", "title"),
+ )
+
+ def test_rename_index_together_to_index_extra_options(self):
+ # Indexes with extra options don't match indexes in index_together.
+ book_partial_index = ModelState(
+ "otherapp",
+ "Book",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ("author", models.ForeignKey("testapp.Author", models.CASCADE)),
+ ("title", models.CharField(max_length=200)),
+ ],
+ {
+ "indexes": [
+ models.Index(
+ fields=["author", "title"],
+ condition=models.Q(title__startswith="The"),
+ name="book_title_author_idx",
+ )
+ ],
+ },
+ )
+ changes = self.get_changes(
+ [AutodetectorTests.author_empty, self.book_index_together],
+ [AutodetectorTests.author_empty, book_partial_index],
+ )
+ self.assertNumberMigrations(changes, "otherapp", 1)
+ self.assertOperationTypes(
+ changes,
+ "otherapp",
+ 0,
+ ["AlterIndexTogether", "AddIndex"],
+ )
+
+ def test_rename_index_together_to_index_order_fields(self):
+ # Indexes with reordered fields don't match indexes in index_together.
+ changes = self.get_changes(
+ [AutodetectorTests.author_empty, self.book_index_together],
+ [AutodetectorTests.author_empty, AutodetectorTests.book_unordered_indexes],
+ )
+ self.assertNumberMigrations(changes, "otherapp", 1)
+ self.assertOperationTypes(
+ changes,
+ "otherapp",
+ 0,
+ ["AlterIndexTogether", "AddIndex"],
+ )
+
+ def test_add_index_together(self):
+ changes = self.get_changes(
+ [AutodetectorTests.author_empty, AutodetectorTests.book],
+ [AutodetectorTests.author_empty, self.book_index_together],
+ )
+ self.assertNumberMigrations(changes, "otherapp", 1)
+ self.assertOperationTypes(changes, "otherapp", 0, ["AlterIndexTogether"])
+ self.assertOperationAttributes(
+ changes, "otherapp", 0, 0, name="book", index_together={("author", "title")}
+ )
+
+ def test_remove_index_together(self):
+ changes = self.get_changes(
+ [AutodetectorTests.author_empty, self.book_index_together],
+ [AutodetectorTests.author_empty, AutodetectorTests.book],
+ )
+ self.assertNumberMigrations(changes, "otherapp", 1)
+ self.assertOperationTypes(changes, "otherapp", 0, ["AlterIndexTogether"])
+ self.assertOperationAttributes(
+ changes, "otherapp", 0, 0, name="book", index_together=set()
+ )
+
+ def test_index_together_remove_fk(self):
+ changes = self.get_changes(
+ [AutodetectorTests.author_empty, self.book_index_together],
+ [AutodetectorTests.author_empty, AutodetectorTests.book_with_no_author],
+ )
+ self.assertNumberMigrations(changes, "otherapp", 1)
+ self.assertOperationTypes(
+ changes,
+ "otherapp",
+ 0,
+ ["AlterIndexTogether", "RemoveField"],
+ )
+ self.assertOperationAttributes(
+ changes, "otherapp", 0, 0, name="book", index_together=set()
+ )
+ self.assertOperationAttributes(
+ changes, "otherapp", 0, 1, model_name="book", name="author"
+ )
+
+ def test_index_together_no_changes(self):
+ """
+ index_together doesn't generate a migration if no changes have been
+ made.
+ """
+ changes = self.get_changes(
+ [AutodetectorTests.author_empty, self.book_index_together],
+ [AutodetectorTests.author_empty, self.book_index_together],
+ )
+ self.assertEqual(len(changes), 0)
+
+ def test_index_together_ordering(self):
+ """index_together triggers on ordering changes."""
+ changes = self.get_changes(
+ [AutodetectorTests.author_empty, self.book_index_together],
+ [AutodetectorTests.author_empty, self.book_index_together_2],
+ )
+ self.assertNumberMigrations(changes, "otherapp", 1)
+ self.assertOperationTypes(
+ changes,
+ "otherapp",
+ 0,
+ ["AlterIndexTogether"],
+ )
+ self.assertOperationAttributes(
+ changes,
+ "otherapp",
+ 0,
+ 0,
+ name="book",
+ index_together={("title", "author")},
+ )
+
+ def test_add_field_and_index_together(self):
+ """
+ Added fields will be created before using them in index_together.
+ """
+ changes = self.get_changes(
+ [AutodetectorTests.author_empty, AutodetectorTests.book],
+ [AutodetectorTests.author_empty, self.book_index_together_3],
+ )
+ self.assertNumberMigrations(changes, "otherapp", 1)
+ self.assertOperationTypes(
+ changes,
+ "otherapp",
+ 0,
+ ["AddField", "AlterIndexTogether"],
+ )
+ self.assertOperationAttributes(
+ changes,
+ "otherapp",
+ 0,
+ 1,
+ name="book",
+ index_together={("title", "newfield")},
+ )
+
+ def test_create_model_and_index_together(self):
+ author = ModelState(
+ "otherapp",
+ "Author",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ("name", models.CharField(max_length=200)),
+ ],
+ )
+ book_with_author = ModelState(
+ "otherapp",
+ "Book",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ("author", models.ForeignKey("otherapp.Author", models.CASCADE)),
+ ("title", models.CharField(max_length=200)),
+ ],
+ {
+ "index_together": {("title", "author")},
+ },
+ )
+ changes = self.get_changes(
+ [AutodetectorTests.book_with_no_author], [author, book_with_author]
+ )
+ self.assertEqual(len(changes["otherapp"]), 1)
+ migration = changes["otherapp"][0]
+ self.assertEqual(len(migration.operations), 3)
+ self.assertOperationTypes(
+ changes,
+ "otherapp",
+ 0,
+ ["CreateModel", "AddField", "AlterIndexTogether"],
+ )
+
+ def test_remove_field_and_index_together(self):
+ """
+ Removed fields will be removed after updating index_together.
+ """
+ changes = self.get_changes(
+ [AutodetectorTests.author_empty, self.book_index_together_3],
+ [AutodetectorTests.author_empty, self.book_index_together],
+ )
+ self.assertNumberMigrations(changes, "otherapp", 1)
+ self.assertOperationTypes(
+ changes,
+ "otherapp",
+ 0,
+ ["AlterIndexTogether", "RemoveField"],
+ )
+ self.assertOperationAttributes(
+ changes,
+ "otherapp",
+ 0,
+ 0,
+ name="book",
+ index_together={("author", "title")},
+ )
+ self.assertOperationAttributes(
+ changes,
+ "otherapp",
+ 0,
+ 1,
+ model_name="book",
+ name="newfield",
+ )
+
+ def test_alter_field_and_index_together(self):
+ """Fields are altered after deleting some index_together."""
+ initial_author = ModelState(
+ "testapp",
+ "Author",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ("name", models.CharField(max_length=200)),
+ ("age", models.IntegerField(db_index=True)),
+ ],
+ {
+ "index_together": {("name",)},
+ },
+ )
+ author_reversed_constraints = ModelState(
+ "testapp",
+ "Author",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ("name", models.CharField(max_length=200, unique=True)),
+ ("age", models.IntegerField()),
+ ],
+ {
+ "index_together": {("age",)},
+ },
+ )
+ changes = self.get_changes([initial_author], [author_reversed_constraints])
+
+ self.assertNumberMigrations(changes, "testapp", 1)
+ self.assertOperationTypes(
+ changes,
+ "testapp",
+ 0,
+ [
+ "AlterIndexTogether",
+ "AlterField",
+ "AlterField",
+ "AlterIndexTogether",
+ ],
+ )
+ self.assertOperationAttributes(
+ changes,
+ "testapp",
+ 0,
+ 0,
+ name="author",
+ index_together=set(),
+ )
+ self.assertOperationAttributes(
+ changes,
+ "testapp",
+ 0,
+ 1,
+ model_name="author",
+ name="age",
+ )
+ self.assertOperationAttributes(
+ changes,
+ "testapp",
+ 0,
+ 2,
+ model_name="author",
+ name="name",
+ )
+ self.assertOperationAttributes(
+ changes,
+ "testapp",
+ 0,
+ 3,
+ name="author",
+ index_together={("age",)},
+ )
+
+ def test_partly_alter_index_together_increase(self):
+ initial_author = ModelState(
+ "testapp",
+ "Author",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ("name", models.CharField(max_length=200)),
+ ("age", models.IntegerField()),
+ ],
+ {
+ "index_together": {("name",)},
+ },
+ )
+ author_new_constraints = ModelState(
+ "testapp",
+ "Author",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ("name", models.CharField(max_length=200)),
+ ("age", models.IntegerField()),
+ ],
+ {
+ "index_together": {("name",), ("age",)},
+ },
+ )
+ changes = self.get_changes([initial_author], [author_new_constraints])
+
+ self.assertNumberMigrations(changes, "testapp", 1)
+ self.assertOperationTypes(
+ changes,
+ "testapp",
+ 0,
+ ["AlterIndexTogether"],
+ )
+ self.assertOperationAttributes(
+ changes,
+ "testapp",
+ 0,
+ 0,
+ name="author",
+ index_together={("name",), ("age",)},
+ )
+
+ def test_partly_alter_index_together_decrease(self):
+ initial_author = ModelState(
+ "testapp",
+ "Author",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ("name", models.CharField(max_length=200)),
+ ("age", models.IntegerField()),
+ ],
+ {
+ "index_together": {("name",), ("age",)},
+ },
+ )
+ author_new_constraints = ModelState(
+ "testapp",
+ "Author",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ("name", models.CharField(max_length=200)),
+ ("age", models.IntegerField()),
+ ],
+ {
+ "index_together": {("age",)},
+ },
+ )
+ changes = self.get_changes([initial_author], [author_new_constraints])
+
+ self.assertNumberMigrations(changes, "testapp", 1)
+ self.assertOperationTypes(
+ changes,
+ "testapp",
+ 0,
+ ["AlterIndexTogether"],
+ )
+ self.assertOperationAttributes(
+ changes,
+ "testapp",
+ 0,
+ 0,
+ name="author",
+ index_together={("age",)},
+ )
+
+ def test_rename_field_and_index_together(self):
+ """Fields are renamed before updating index_together."""
+ changes = self.get_changes(
+ [AutodetectorTests.author_empty, self.book_index_together_3],
+ [AutodetectorTests.author_empty, self.book_index_together_4],
+ MigrationQuestioner({"ask_rename": True}),
+ )
+ self.assertNumberMigrations(changes, "otherapp", 1)
+ self.assertOperationTypes(
+ changes,
+ "otherapp",
+ 0,
+ ["RenameField", "AlterIndexTogether"],
+ )
+ self.assertOperationAttributes(
+ changes,
+ "otherapp",
+ 0,
+ 1,
+ name="book",
+ index_together={("title", "newfield2")},
+ )
+
+ def test_add_model_order_with_respect_to_index_together(self):
+ changes = self.get_changes(
+ [],
+ [
+ AutodetectorTests.book,
+ ModelState(
+ "testapp",
+ "Author",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ("name", models.CharField(max_length=200)),
+ ("book", models.ForeignKey("otherapp.Book", models.CASCADE)),
+ ],
+ options={
+ "order_with_respect_to": "book",
+ "index_together": {("name", "_order")},
+ },
+ ),
+ ],
+ )
+ self.assertNumberMigrations(changes, "testapp", 1)
+ self.assertOperationTypes(changes, "testapp", 0, ["CreateModel"])
+ self.assertOperationAttributes(
+ changes,
+ "testapp",
+ 0,
+ 0,
+ name="Author",
+ options={
+ "order_with_respect_to": "book",
+ "index_together": {("name", "_order")},
+ },
+ )
+
+ def test_set_alter_order_with_respect_to_index_together(self):
+ after = ModelState(
+ "testapp",
+ "Author",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ("name", models.CharField(max_length=200)),
+ ("book", models.ForeignKey("otherapp.Book", models.CASCADE)),
+ ],
+ options={
+ "order_with_respect_to": "book",
+ "index_together": {("name", "_order")},
+ },
+ )
+ changes = self.get_changes(
+ [AutodetectorTests.book, AutodetectorTests.author_with_book],
+ [AutodetectorTests.book, after],
+ )
+ self.assertNumberMigrations(changes, "testapp", 1)
+ self.assertOperationTypes(
+ changes,
+ "testapp",
+ 0,
+ ["AlterOrderWithRespectTo", "AlterIndexTogether"],
+ )
+
+
+class MigrationSuggestNameTests(SimpleTestCase):
+ def test_no_operations(self):
+ class Migration(migrations.Migration):
+ operations = []
+
+ migration = Migration("some_migration", "test_app")
+ self.assertIs(migration.suggest_name().startswith("auto_"), True)
+
+ def test_no_operations_initial(self):
+ class Migration(migrations.Migration):
+ initial = True
+ operations = []
+
+ migration = Migration("some_migration", "test_app")
+ self.assertEqual(migration.suggest_name(), "initial")
+
+ def test_single_operation(self):
+ class Migration(migrations.Migration):
+ operations = [migrations.CreateModel("Person", fields=[])]
+
+ migration = Migration("0001_initial", "test_app")
+ self.assertEqual(migration.suggest_name(), "person")
+
+ class Migration(migrations.Migration):
+ operations = [migrations.DeleteModel("Person")]
+
+ migration = Migration("0002_initial", "test_app")
+ self.assertEqual(migration.suggest_name(), "delete_person")
+
+ def test_single_operation_long_name(self):
+ class Migration(migrations.Migration):
+ operations = [migrations.CreateModel("A" * 53, fields=[])]
+
+ migration = Migration("some_migration", "test_app")
+ self.assertEqual(migration.suggest_name(), "a" * 53)
+
+ def test_two_operations(self):
+ class Migration(migrations.Migration):
+ operations = [
+ migrations.CreateModel("Person", fields=[]),
+ migrations.DeleteModel("Animal"),
+ ]
+
+ migration = Migration("some_migration", "test_app")
+ self.assertEqual(migration.suggest_name(), "person_delete_animal")
+
+ def test_two_create_models(self):
+ class Migration(migrations.Migration):
+ operations = [
+ migrations.CreateModel("Person", fields=[]),
+ migrations.CreateModel("Animal", fields=[]),
+ ]
+
+ migration = Migration("0001_initial", "test_app")
+ self.assertEqual(migration.suggest_name(), "person_animal")
+
+ def test_two_create_models_with_initial_true(self):
+ class Migration(migrations.Migration):
+ initial = True
+ operations = [
+ migrations.CreateModel("Person", fields=[]),
+ migrations.CreateModel("Animal", fields=[]),
+ ]
+
+ migration = Migration("0001_initial", "test_app")
+ self.assertEqual(migration.suggest_name(), "initial")
+
+ def test_many_operations_suffix(self):
+ class Migration(migrations.Migration):
+ operations = [
+ migrations.CreateModel("Person1", fields=[]),
+ migrations.CreateModel("Person2", fields=[]),
+ migrations.CreateModel("Person3", fields=[]),
+ migrations.DeleteModel("Person4"),
+ migrations.DeleteModel("Person5"),
+ ]
+
+ migration = Migration("some_migration", "test_app")
+ self.assertEqual(
+ migration.suggest_name(),
+ "person1_person2_person3_delete_person4_and_more",
+ )
+
+ def test_operation_with_no_suggested_name(self):
+ class Migration(migrations.Migration):
+ operations = [
+ migrations.CreateModel("Person", fields=[]),
+ migrations.RunSQL("SELECT 1 FROM person;"),
+ ]
+
+ migration = Migration("some_migration", "test_app")
+ self.assertIs(migration.suggest_name().startswith("auto_"), True)
+
+ def test_operation_with_invalid_chars_in_suggested_name(self):
+ class Migration(migrations.Migration):
+ operations = [
+ migrations.AddConstraint(
+ "Person",
+ models.UniqueConstraint(
+ fields=["name"], name="person.name-*~unique!"
+ ),
+ ),
+ ]
+
+ migration = Migration("some_migration", "test_app")
+ self.assertEqual(migration.suggest_name(), "person_person_name_unique_")
+
+ def test_none_name(self):
+ class Migration(migrations.Migration):
+ operations = [migrations.RunSQL("SELECT 1 FROM person;")]
+
+ migration = Migration("0001_initial", "test_app")
+ suggest_name = migration.suggest_name()
+ self.assertIs(suggest_name.startswith("auto_"), True)
+
+ def test_none_name_with_initial_true(self):
+ class Migration(migrations.Migration):
+ initial = True
+ operations = [migrations.RunSQL("SELECT 1 FROM person;")]
+
+ migration = Migration("0001_initial", "test_app")
+ self.assertEqual(migration.suggest_name(), "initial")
+
+ def test_auto(self):
+ migration = migrations.Migration("0001_initial", "test_app")
+ suggest_name = migration.suggest_name()
+ self.assertIs(suggest_name.startswith("auto_"), True)
diff --git a/testbed/django__django/tests/migrations/test_base.py b/testbed/django__django/tests/migrations/test_base.py
new file mode 100644
index 0000000000000000000000000000000000000000..b5228ad44538b504fe8ba684f61b7d2596273f0f
--- /dev/null
+++ b/testbed/django__django/tests/migrations/test_base.py
@@ -0,0 +1,405 @@
+import os
+import shutil
+import tempfile
+from contextlib import contextmanager
+from importlib import import_module
+
+from django.apps import apps
+from django.db import connection, connections, migrations, models
+from django.db.migrations.migration import Migration
+from django.db.migrations.recorder import MigrationRecorder
+from django.db.migrations.state import ProjectState
+from django.test import TransactionTestCase
+from django.test.utils import extend_sys_path
+from django.utils.module_loading import module_dir
+
+
+class MigrationTestBase(TransactionTestCase):
+ """
+ Contains an extended set of asserts for testing migrations and schema operations.
+ """
+
+ available_apps = ["migrations"]
+ databases = {"default", "other"}
+
+ def tearDown(self):
+ # Reset applied-migrations state.
+ for db in self.databases:
+ recorder = MigrationRecorder(connections[db])
+ recorder.migration_qs.filter(app="migrations").delete()
+
+ def get_table_description(self, table, using="default"):
+ with connections[using].cursor() as cursor:
+ return connections[using].introspection.get_table_description(cursor, table)
+
+ def assertTableExists(self, table, using="default"):
+ with connections[using].cursor() as cursor:
+ self.assertIn(table, connections[using].introspection.table_names(cursor))
+
+ def assertTableNotExists(self, table, using="default"):
+ with connections[using].cursor() as cursor:
+ self.assertNotIn(
+ table, connections[using].introspection.table_names(cursor)
+ )
+
+ def assertColumnExists(self, table, column, using="default"):
+ self.assertIn(
+ column, [c.name for c in self.get_table_description(table, using=using)]
+ )
+
+ def assertColumnNotExists(self, table, column, using="default"):
+ self.assertNotIn(
+ column, [c.name for c in self.get_table_description(table, using=using)]
+ )
+
+ def _get_column_allows_null(self, table, column, using):
+ return [
+ c.null_ok
+ for c in self.get_table_description(table, using=using)
+ if c.name == column
+ ][0]
+
+ def assertColumnNull(self, table, column, using="default"):
+ self.assertTrue(self._get_column_allows_null(table, column, using))
+
+ def assertColumnNotNull(self, table, column, using="default"):
+ self.assertFalse(self._get_column_allows_null(table, column, using))
+
+ def _get_column_collation(self, table, column, using):
+ return next(
+ f.collation
+ for f in self.get_table_description(table, using=using)
+ if f.name == column
+ )
+
+ def assertColumnCollation(self, table, column, collation, using="default"):
+ self.assertEqual(self._get_column_collation(table, column, using), collation)
+
+ def _get_table_comment(self, table, using):
+ with connections[using].cursor() as cursor:
+ return next(
+ t.comment
+ for t in connections[using].introspection.get_table_list(cursor)
+ if t.name == table
+ )
+
+ def assertTableComment(self, table, comment, using="default"):
+ self.assertEqual(self._get_table_comment(table, using), comment)
+
+ def assertTableCommentNotExists(self, table, using="default"):
+ self.assertIn(self._get_table_comment(table, using), [None, ""])
+
+ def assertIndexExists(
+ self, table, columns, value=True, using="default", index_type=None
+ ):
+ with connections[using].cursor() as cursor:
+ self.assertEqual(
+ value,
+ any(
+ c["index"]
+ for c in connections[using]
+ .introspection.get_constraints(cursor, table)
+ .values()
+ if (
+ c["columns"] == list(columns)
+ and (index_type is None or c["type"] == index_type)
+ and not c["unique"]
+ )
+ ),
+ )
+
+ def assertIndexNotExists(self, table, columns):
+ return self.assertIndexExists(table, columns, False)
+
+ def assertIndexNameExists(self, table, index, using="default"):
+ with connections[using].cursor() as cursor:
+ self.assertIn(
+ index,
+ connection.introspection.get_constraints(cursor, table),
+ )
+
+ def assertIndexNameNotExists(self, table, index, using="default"):
+ with connections[using].cursor() as cursor:
+ self.assertNotIn(
+ index,
+ connection.introspection.get_constraints(cursor, table),
+ )
+
+ def assertConstraintExists(self, table, name, value=True, using="default"):
+ with connections[using].cursor() as cursor:
+ constraints = (
+ connections[using].introspection.get_constraints(cursor, table).items()
+ )
+ self.assertEqual(
+ value,
+ any(c["check"] for n, c in constraints if n == name),
+ )
+
+ def assertConstraintNotExists(self, table, name):
+ return self.assertConstraintExists(table, name, False)
+
+ def assertUniqueConstraintExists(self, table, columns, value=True, using="default"):
+ with connections[using].cursor() as cursor:
+ constraints = (
+ connections[using].introspection.get_constraints(cursor, table).values()
+ )
+ self.assertEqual(
+ value,
+ any(c["unique"] for c in constraints if c["columns"] == list(columns)),
+ )
+
+ def assertFKExists(self, table, columns, to, value=True, using="default"):
+ if not connections[using].features.can_introspect_foreign_keys:
+ return
+ with connections[using].cursor() as cursor:
+ self.assertEqual(
+ value,
+ any(
+ c["foreign_key"] == to
+ for c in connections[using]
+ .introspection.get_constraints(cursor, table)
+ .values()
+ if c["columns"] == list(columns)
+ ),
+ )
+
+ def assertFKNotExists(self, table, columns, to):
+ return self.assertFKExists(table, columns, to, False)
+
+ @contextmanager
+ def temporary_migration_module(self, app_label="migrations", module=None):
+ """
+ Allows testing management commands in a temporary migrations module.
+
+ Wrap all invocations to makemigrations and squashmigrations with this
+ context manager in order to avoid creating migration files in your
+ source tree inadvertently.
+
+ Takes the application label that will be passed to makemigrations or
+ squashmigrations and the Python path to a migrations module.
+
+ The migrations module is used as a template for creating the temporary
+ migrations module. If it isn't provided, the application's migrations
+ module is used, if it exists.
+
+ Returns the filesystem path to the temporary migrations module.
+ """
+ with tempfile.TemporaryDirectory() as temp_dir:
+ target_dir = tempfile.mkdtemp(dir=temp_dir)
+ with open(os.path.join(target_dir, "__init__.py"), "w"):
+ pass
+ target_migrations_dir = os.path.join(target_dir, "migrations")
+
+ if module is None:
+ module = apps.get_app_config(app_label).name + ".migrations"
+
+ try:
+ source_migrations_dir = module_dir(import_module(module))
+ except (ImportError, ValueError):
+ pass
+ else:
+ shutil.copytree(source_migrations_dir, target_migrations_dir)
+
+ with extend_sys_path(temp_dir):
+ new_module = os.path.basename(target_dir) + ".migrations"
+ with self.settings(MIGRATION_MODULES={app_label: new_module}):
+ yield target_migrations_dir
+
+
+class OperationTestBase(MigrationTestBase):
+ """Common functions to help test operations."""
+
+ @classmethod
+ def setUpClass(cls):
+ super().setUpClass()
+ cls._initial_table_names = frozenset(connection.introspection.table_names())
+
+ def tearDown(self):
+ self.cleanup_test_tables()
+ super().tearDown()
+
+ def cleanup_test_tables(self):
+ table_names = (
+ frozenset(connection.introspection.table_names())
+ - self._initial_table_names
+ )
+ with connection.schema_editor() as editor:
+ with connection.constraint_checks_disabled():
+ for table_name in table_names:
+ editor.execute(
+ editor.sql_delete_table
+ % {
+ "table": editor.quote_name(table_name),
+ }
+ )
+
+ def apply_operations(self, app_label, project_state, operations, atomic=True):
+ migration = Migration("name", app_label)
+ migration.operations = operations
+ with connection.schema_editor(atomic=atomic) as editor:
+ return migration.apply(project_state, editor)
+
+ def unapply_operations(self, app_label, project_state, operations, atomic=True):
+ migration = Migration("name", app_label)
+ migration.operations = operations
+ with connection.schema_editor(atomic=atomic) as editor:
+ return migration.unapply(project_state, editor)
+
+ def make_test_state(self, app_label, operation, **kwargs):
+ """
+ Makes a test state using set_up_test_model and returns the
+ original state and the state after the migration is applied.
+ """
+ project_state = self.set_up_test_model(app_label, **kwargs)
+ new_state = project_state.clone()
+ operation.state_forwards(app_label, new_state)
+ return project_state, new_state
+
+ def set_up_test_model(
+ self,
+ app_label,
+ second_model=False,
+ third_model=False,
+ index=False,
+ multicol_index=False,
+ related_model=False,
+ mti_model=False,
+ proxy_model=False,
+ manager_model=False,
+ unique_together=False,
+ options=False,
+ db_table=None,
+ index_together=False, # RemovedInDjango51Warning.
+ constraints=None,
+ indexes=None,
+ ):
+ """Creates a test model state and database table."""
+ # Make the "current" state.
+ model_options = {
+ "swappable": "TEST_SWAP_MODEL",
+ # RemovedInDjango51Warning.
+ "index_together": [["weight", "pink"]] if index_together else [],
+ "unique_together": [["pink", "weight"]] if unique_together else [],
+ }
+ if options:
+ model_options["permissions"] = [("can_groom", "Can groom")]
+ if db_table:
+ model_options["db_table"] = db_table
+ operations = [
+ migrations.CreateModel(
+ "Pony",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ("pink", models.IntegerField(default=3)),
+ ("weight", models.FloatField()),
+ ("green", models.IntegerField(null=True)),
+ (
+ "yellow",
+ models.CharField(
+ blank=True, null=True, db_default="Yellow", max_length=20
+ ),
+ ),
+ ],
+ options=model_options,
+ )
+ ]
+ if index:
+ operations.append(
+ migrations.AddIndex(
+ "Pony",
+ models.Index(fields=["pink"], name="pony_pink_idx"),
+ )
+ )
+ if multicol_index:
+ operations.append(
+ migrations.AddIndex(
+ "Pony",
+ models.Index(fields=["pink", "weight"], name="pony_test_idx"),
+ )
+ )
+ if indexes:
+ for index in indexes:
+ operations.append(migrations.AddIndex("Pony", index))
+ if constraints:
+ for constraint in constraints:
+ operations.append(migrations.AddConstraint("Pony", constraint))
+ if second_model:
+ operations.append(
+ migrations.CreateModel(
+ "Stable",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ],
+ )
+ )
+ if third_model:
+ operations.append(
+ migrations.CreateModel(
+ "Van",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ],
+ )
+ )
+ if related_model:
+ operations.append(
+ migrations.CreateModel(
+ "Rider",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ("pony", models.ForeignKey("Pony", models.CASCADE)),
+ (
+ "friend",
+ models.ForeignKey("self", models.CASCADE, null=True),
+ ),
+ ],
+ )
+ )
+ if mti_model:
+ operations.append(
+ migrations.CreateModel(
+ "ShetlandPony",
+ fields=[
+ (
+ "pony_ptr",
+ models.OneToOneField(
+ "Pony",
+ models.CASCADE,
+ auto_created=True,
+ parent_link=True,
+ primary_key=True,
+ to_field="id",
+ serialize=False,
+ ),
+ ),
+ ("cuteness", models.IntegerField(default=1)),
+ ],
+ bases=["%s.Pony" % app_label],
+ )
+ )
+ if proxy_model:
+ operations.append(
+ migrations.CreateModel(
+ "ProxyPony",
+ fields=[],
+ options={"proxy": True},
+ bases=["%s.Pony" % app_label],
+ )
+ )
+ if manager_model:
+ from .models import FoodManager, FoodQuerySet
+
+ operations.append(
+ migrations.CreateModel(
+ "Food",
+ fields=[
+ ("id", models.AutoField(primary_key=True)),
+ ],
+ managers=[
+ ("food_qs", FoodQuerySet.as_manager()),
+ ("food_mgr", FoodManager("a", "b")),
+ ("food_mgr_kwargs", FoodManager("x", "y", 3, 4)),
+ ],
+ )
+ )
+ return self.apply_operations(app_label, ProjectState(), operations)
diff --git a/testbed/django__django/tests/migrations/test_commands.py b/testbed/django__django/tests/migrations/test_commands.py
new file mode 100644
index 0000000000000000000000000000000000000000..387cef924af3328a076b8a1994ad9f167a20e89d
--- /dev/null
+++ b/testbed/django__django/tests/migrations/test_commands.py
@@ -0,0 +1,3212 @@
+import datetime
+import importlib
+import io
+import os
+import shutil
+import sys
+from unittest import mock
+
+from django.apps import apps
+from django.core.management import CommandError, call_command
+from django.db import (
+ ConnectionHandler,
+ DatabaseError,
+ OperationalError,
+ connection,
+ connections,
+ models,
+)
+from django.db.backends.base.schema import BaseDatabaseSchemaEditor
+from django.db.backends.utils import truncate_name
+from django.db.migrations.exceptions import InconsistentMigrationHistory
+from django.db.migrations.recorder import MigrationRecorder
+from django.test import TestCase, override_settings, skipUnlessDBFeature
+from django.test.utils import captured_stdout
+from django.utils import timezone
+from django.utils.version import get_docs_version
+
+from .models import UnicodeModel, UnserializableModel
+from .routers import TestRouter
+from .test_base import MigrationTestBase
+
+HAS_BLACK = shutil.which("black")
+
+
+class MigrateTests(MigrationTestBase):
+ """
+ Tests running the migrate command.
+ """
+
+ databases = {"default", "other"}
+
+ @override_settings(MIGRATION_MODULES={"migrations": "migrations.test_migrations"})
+ def test_migrate(self):
+ """
+ Tests basic usage of the migrate command.
+ """
+ # No tables are created
+ self.assertTableNotExists("migrations_author")
+ self.assertTableNotExists("migrations_tribble")
+ self.assertTableNotExists("migrations_book")
+ # Run the migrations to 0001 only
+ stdout = io.StringIO()
+ call_command(
+ "migrate", "migrations", "0001", verbosity=2, stdout=stdout, no_color=True
+ )
+ stdout = stdout.getvalue()
+ self.assertIn(
+ "Target specific migration: 0001_initial, from migrations", stdout
+ )
+ self.assertIn("Applying migrations.0001_initial... OK", stdout)
+ self.assertIn("Running pre-migrate handlers for application migrations", stdout)
+ self.assertIn(
+ "Running post-migrate handlers for application migrations", stdout
+ )
+ # The correct tables exist
+ self.assertTableExists("migrations_author")
+ self.assertTableExists("migrations_tribble")
+ self.assertTableNotExists("migrations_book")
+ # Run migrations all the way
+ call_command("migrate", verbosity=0)
+ # The correct tables exist
+ self.assertTableExists("migrations_author")
+ self.assertTableNotExists("migrations_tribble")
+ self.assertTableExists("migrations_book")
+ # Unmigrate everything
+ stdout = io.StringIO()
+ call_command(
+ "migrate", "migrations", "zero", verbosity=2, stdout=stdout, no_color=True
+ )
+ stdout = stdout.getvalue()
+ self.assertIn("Unapply all migrations: migrations", stdout)
+ self.assertIn("Unapplying migrations.0002_second... OK", stdout)
+ self.assertIn("Running pre-migrate handlers for application migrations", stdout)
+ self.assertIn(
+ "Running post-migrate handlers for application migrations", stdout
+ )
+ # Tables are gone
+ self.assertTableNotExists("migrations_author")
+ self.assertTableNotExists("migrations_tribble")
+ self.assertTableNotExists("migrations_book")
+
+ @override_settings(
+ INSTALLED_APPS=[
+ "django.contrib.auth",
+ "django.contrib.contenttypes",
+ "migrations.migrations_test_apps.migrated_app",
+ ]
+ )
+ def test_migrate_with_system_checks(self):
+ out = io.StringIO()
+ call_command("migrate", skip_checks=False, no_color=True, stdout=out)
+ self.assertIn("Apply all migrations: migrated_app", out.getvalue())
+
+ @override_settings(
+ INSTALLED_APPS=[
+ "migrations",
+ "migrations.migrations_test_apps.unmigrated_app_syncdb",
+ ]
+ )
+ def test_app_without_migrations(self):
+ msg = "App 'unmigrated_app_syncdb' does not have migrations."
+ with self.assertRaisesMessage(CommandError, msg):
+ call_command("migrate", app_label="unmigrated_app_syncdb")
+
+ @override_settings(
+ MIGRATION_MODULES={"migrations": "migrations.test_migrations_clashing_prefix"}
+ )
+ def test_ambiguous_prefix(self):
+ msg = (
+ "More than one migration matches 'a' in app 'migrations'. Please "
+ "be more specific."
+ )
+ with self.assertRaisesMessage(CommandError, msg):
+ call_command("migrate", app_label="migrations", migration_name="a")
+
+ @override_settings(MIGRATION_MODULES={"migrations": "migrations.test_migrations"})
+ def test_unknown_prefix(self):
+ msg = "Cannot find a migration matching 'nonexistent' from app 'migrations'."
+ with self.assertRaisesMessage(CommandError, msg):
+ call_command(
+ "migrate", app_label="migrations", migration_name="nonexistent"
+ )
+
+ @override_settings(
+ MIGRATION_MODULES={"migrations": "migrations.test_migrations_initial_false"}
+ )
+ def test_migrate_initial_false(self):
+ """
+ `Migration.initial = False` skips fake-initial detection.
+ """
+ # Make sure no tables are created
+ self.assertTableNotExists("migrations_author")
+ self.assertTableNotExists("migrations_tribble")
+ # Run the migrations to 0001 only
+ call_command("migrate", "migrations", "0001", verbosity=0)
+ # Fake rollback
+ call_command("migrate", "migrations", "zero", fake=True, verbosity=0)
+ # Make sure fake-initial detection does not run
+ with self.assertRaises(DatabaseError):
+ call_command(
+ "migrate", "migrations", "0001", fake_initial=True, verbosity=0
+ )
+
+ call_command("migrate", "migrations", "0001", fake=True, verbosity=0)
+ # Real rollback
+ call_command("migrate", "migrations", "zero", verbosity=0)
+ # Make sure it's all gone
+ self.assertTableNotExists("migrations_author")
+ self.assertTableNotExists("migrations_tribble")
+ self.assertTableNotExists("migrations_book")
+
+ @override_settings(
+ MIGRATION_MODULES={"migrations": "migrations.test_migrations"},
+ DATABASE_ROUTERS=["migrations.routers.TestRouter"],
+ )
+ def test_migrate_fake_initial(self):
+ """
+ --fake-initial only works if all tables created in the initial
+ migration of an app exists. Database routers must be obeyed when doing
+ that check.
+ """
+ # Make sure no tables are created
+ for db in self.databases:
+ self.assertTableNotExists("migrations_author", using=db)
+ self.assertTableNotExists("migrations_tribble", using=db)
+
+ try:
+ # Run the migrations to 0001 only
+ call_command("migrate", "migrations", "0001", verbosity=0)
+ call_command("migrate", "migrations", "0001", verbosity=0, database="other")
+ # Make sure the right tables exist
+ self.assertTableExists("migrations_author")
+ self.assertTableNotExists("migrations_tribble")
+ # Also check the "other" database
+ self.assertTableNotExists("migrations_author", using="other")
+ self.assertTableExists("migrations_tribble", using="other")
+ # Fake a roll-back
+ call_command("migrate", "migrations", "zero", fake=True, verbosity=0)
+ call_command(
+ "migrate",
+ "migrations",
+ "zero",
+ fake=True,
+ verbosity=0,
+ database="other",
+ )
+ # Make sure the tables still exist
+ self.assertTableExists("migrations_author")
+ self.assertTableExists("migrations_tribble", using="other")
+ # Try to run initial migration
+ with self.assertRaises(DatabaseError):
+ call_command("migrate", "migrations", "0001", verbosity=0)
+ # Run initial migration with an explicit --fake-initial
+ out = io.StringIO()
+ with mock.patch(
+ "django.core.management.color.supports_color", lambda *args: False
+ ):
+ call_command(
+ "migrate",
+ "migrations",
+ "0001",
+ fake_initial=True,
+ stdout=out,
+ verbosity=1,
+ )
+ call_command(
+ "migrate",
+ "migrations",
+ "0001",
+ fake_initial=True,
+ verbosity=0,
+ database="other",
+ )
+ self.assertIn("migrations.0001_initial... faked", out.getvalue().lower())
+
+ # Run migrations all the way.
+ call_command("migrate", verbosity=0)
+ call_command("migrate", verbosity=0, database="other")
+ self.assertTableExists("migrations_author")
+ self.assertTableNotExists("migrations_tribble")
+ self.assertTableExists("migrations_book")
+ self.assertTableNotExists("migrations_author", using="other")
+ self.assertTableNotExists("migrations_tribble", using="other")
+ self.assertTableNotExists("migrations_book", using="other")
+ # Fake a roll-back.
+ call_command("migrate", "migrations", "zero", fake=True, verbosity=0)
+ call_command(
+ "migrate",
+ "migrations",
+ "zero",
+ fake=True,
+ verbosity=0,
+ database="other",
+ )
+ self.assertTableExists("migrations_author")
+ self.assertTableNotExists("migrations_tribble")
+ self.assertTableExists("migrations_book")
+ # Run initial migration.
+ with self.assertRaises(DatabaseError):
+ call_command("migrate", "migrations", verbosity=0)
+ # Run initial migration with an explicit --fake-initial.
+ with self.assertRaises(DatabaseError):
+ # Fails because "migrations_tribble" does not exist but needs
+ # to in order to make --fake-initial work.
+ call_command("migrate", "migrations", fake_initial=True, verbosity=0)
+ # Fake an apply.
+ call_command("migrate", "migrations", fake=True, verbosity=0)
+ call_command(
+ "migrate", "migrations", fake=True, verbosity=0, database="other"
+ )
+ finally:
+ # Unmigrate everything.
+ call_command("migrate", "migrations", "zero", verbosity=0)
+ call_command("migrate", "migrations", "zero", verbosity=0, database="other")
+ # Make sure it's all gone
+ for db in self.databases:
+ self.assertTableNotExists("migrations_author", using=db)
+ self.assertTableNotExists("migrations_tribble", using=db)
+ self.assertTableNotExists("migrations_book", using=db)
+
+ @skipUnlessDBFeature("ignores_table_name_case")
+ def test_migrate_fake_initial_case_insensitive(self):
+ with override_settings(
+ MIGRATION_MODULES={
+ "migrations": "migrations.test_fake_initial_case_insensitive.initial",
+ }
+ ):
+ call_command("migrate", "migrations", "0001", verbosity=0)
+ call_command("migrate", "migrations", "zero", fake=True, verbosity=0)
+
+ with override_settings(
+ MIGRATION_MODULES={
+ "migrations": (
+ "migrations.test_fake_initial_case_insensitive.fake_initial"
+ ),
+ }
+ ):
+ out = io.StringIO()
+ call_command(
+ "migrate",
+ "migrations",
+ "0001",
+ fake_initial=True,
+ stdout=out,
+ verbosity=1,
+ no_color=True,
+ )
+ self.assertIn(
+ "migrations.0001_initial... faked",
+ out.getvalue().lower(),
+ )
+
+ @override_settings(
+ MIGRATION_MODULES={
+ "migrations": "migrations.test_migrations_fake_split_initial"
+ }
+ )
+ def test_migrate_fake_split_initial(self):
+ """
+ Split initial migrations can be faked with --fake-initial.
+ """
+ try:
+ call_command("migrate", "migrations", "0002", verbosity=0)
+ call_command("migrate", "migrations", "zero", fake=True, verbosity=0)
+ out = io.StringIO()
+ with mock.patch(
+ "django.core.management.color.supports_color", lambda *args: False
+ ):
+ call_command(
+ "migrate",
+ "migrations",
+ "0002",
+ fake_initial=True,
+ stdout=out,
+ verbosity=1,
+ )
+ value = out.getvalue().lower()
+ self.assertIn("migrations.0001_initial... faked", value)
+ self.assertIn("migrations.0002_second... faked", value)
+ finally:
+ # Fake an apply.
+ call_command("migrate", "migrations", fake=True, verbosity=0)
+ # Unmigrate everything.
+ call_command("migrate", "migrations", "zero", verbosity=0)
+
+ @override_settings(
+ MIGRATION_MODULES={"migrations": "migrations.test_migrations_conflict"}
+ )
+ def test_migrate_conflict_exit(self):
+ """
+ migrate exits if it detects a conflict.
+ """
+ msg = (
+ "Conflicting migrations detected; multiple leaf nodes in the "
+ "migration graph: (0002_conflicting_second, 0002_second in "
+ "migrations).\n"
+ "To fix them run 'python manage.py makemigrations --merge'"
+ )
+ with self.assertRaisesMessage(CommandError, msg):
+ call_command("migrate", "migrations")
+
+ @override_settings(
+ MIGRATION_MODULES={
+ "migrations": "migrations.test_migrations",
+ }
+ )
+ def test_migrate_check(self):
+ with self.assertRaises(SystemExit):
+ call_command("migrate", "migrations", "0001", check_unapplied=True)
+ self.assertTableNotExists("migrations_author")
+ self.assertTableNotExists("migrations_tribble")
+ self.assertTableNotExists("migrations_book")
+
+ @override_settings(
+ INSTALLED_APPS=[
+ "migrations.migrations_test_apps.migrated_app",
+ ]
+ )
+ def test_migrate_check_migrated_app(self):
+ out = io.StringIO()
+ try:
+ call_command("migrate", "migrated_app", verbosity=0)
+ call_command(
+ "migrate",
+ "migrated_app",
+ stdout=out,
+ check_unapplied=True,
+ )
+ self.assertEqual(out.getvalue(), "")
+ finally:
+ # Unmigrate everything.
+ call_command("migrate", "migrated_app", "zero", verbosity=0)
+
+ @override_settings(
+ MIGRATION_MODULES={
+ "migrations": "migrations.test_migrations_plan",
+ }
+ )
+ def test_migrate_check_plan(self):
+ out = io.StringIO()
+ with self.assertRaises(SystemExit):
+ call_command(
+ "migrate",
+ "migrations",
+ "0001",
+ check_unapplied=True,
+ plan=True,
+ stdout=out,
+ no_color=True,
+ )
+ self.assertEqual(
+ "Planned operations:\n"
+ "migrations.0001_initial\n"
+ " Create model Salamander\n"
+ " Raw Python operation -> Grow salamander tail.\n",
+ out.getvalue(),
+ )
+
+ @override_settings(MIGRATION_MODULES={"migrations": "migrations.test_migrations"})
+ def test_showmigrations_list(self):
+ """
+ showmigrations --list displays migrations and whether or not they're
+ applied.
+ """
+ out = io.StringIO()
+ with mock.patch(
+ "django.core.management.color.supports_color", lambda *args: True
+ ):
+ call_command(
+ "showmigrations", format="list", stdout=out, verbosity=0, no_color=False
+ )
+ self.assertEqual(
+ "\x1b[1mmigrations\n\x1b[0m [ ] 0001_initial\n [ ] 0002_second\n",
+ out.getvalue().lower(),
+ )
+
+ call_command("migrate", "migrations", "0001", verbosity=0)
+
+ out = io.StringIO()
+ # Giving the explicit app_label tests for selective `show_list` in the command
+ call_command(
+ "showmigrations",
+ "migrations",
+ format="list",
+ stdout=out,
+ verbosity=0,
+ no_color=True,
+ )
+ self.assertEqual(
+ "migrations\n [x] 0001_initial\n [ ] 0002_second\n", out.getvalue().lower()
+ )
+ out = io.StringIO()
+ # Applied datetimes are displayed at verbosity 2+.
+ call_command(
+ "showmigrations", "migrations", stdout=out, verbosity=2, no_color=True
+ )
+ migration1 = MigrationRecorder(connection).migration_qs.get(
+ app="migrations", name="0001_initial"
+ )
+ self.assertEqual(
+ "migrations\n"
+ " [x] 0001_initial (applied at %s)\n"
+ " [ ] 0002_second\n" % migration1.applied.strftime("%Y-%m-%d %H:%M:%S"),
+ out.getvalue().lower(),
+ )
+ # Cleanup by unmigrating everything
+ call_command("migrate", "migrations", "zero", verbosity=0)
+
+ @override_settings(
+ MIGRATION_MODULES={"migrations": "migrations.test_migrations_squashed"}
+ )
+ def test_showmigrations_list_squashed(self):
+ out = io.StringIO()
+ call_command(
+ "showmigrations", format="list", stdout=out, verbosity=2, no_color=True
+ )
+ self.assertEqual(
+ "migrations\n [ ] 0001_squashed_0002 (2 squashed migrations)\n",
+ out.getvalue().lower(),
+ )
+ out = io.StringIO()
+ call_command(
+ "migrate",
+ "migrations",
+ "0001_squashed_0002",
+ stdout=out,
+ verbosity=2,
+ no_color=True,
+ )
+ try:
+ self.assertIn(
+ "operations to perform:\n"
+ " target specific migration: 0001_squashed_0002, from migrations\n"
+ "running pre-migrate handlers for application migrations\n"
+ "running migrations:\n"
+ " applying migrations.0001_squashed_0002... ok (",
+ out.getvalue().lower(),
+ )
+ out = io.StringIO()
+ call_command(
+ "showmigrations", format="list", stdout=out, verbosity=2, no_color=True
+ )
+ self.assertEqual(
+ "migrations\n [x] 0001_squashed_0002 (2 squashed migrations)\n",
+ out.getvalue().lower(),
+ )
+ finally:
+ # Unmigrate everything.
+ call_command("migrate", "migrations", "zero", verbosity=0)
+
+ @override_settings(
+ MIGRATION_MODULES={"migrations": "migrations.test_migrations_run_before"}
+ )
+ def test_showmigrations_plan(self):
+ """
+ Tests --plan output of showmigrations command
+ """
+ out = io.StringIO()
+ call_command("showmigrations", format="plan", stdout=out)
+ self.assertEqual(
+ "[ ] migrations.0001_initial\n"
+ "[ ] migrations.0003_third\n"
+ "[ ] migrations.0002_second\n",
+ out.getvalue().lower(),
+ )
+
+ out = io.StringIO()
+ call_command("showmigrations", format="plan", stdout=out, verbosity=2)
+ self.assertEqual(
+ "[ ] migrations.0001_initial\n"
+ "[ ] migrations.0003_third ... (migrations.0001_initial)\n"
+ "[ ] migrations.0002_second ... (migrations.0001_initial, "
+ "migrations.0003_third)\n",
+ out.getvalue().lower(),
+ )
+ call_command("migrate", "migrations", "0003", verbosity=0)
+
+ out = io.StringIO()
+ call_command("showmigrations", format="plan", stdout=out)
+ self.assertEqual(
+ "[x] migrations.0001_initial\n"
+ "[x] migrations.0003_third\n"
+ "[ ] migrations.0002_second\n",
+ out.getvalue().lower(),
+ )
+
+ out = io.StringIO()
+ call_command("showmigrations", format="plan", stdout=out, verbosity=2)
+ self.assertEqual(
+ "[x] migrations.0001_initial\n"
+ "[x] migrations.0003_third ... (migrations.0001_initial)\n"
+ "[ ] migrations.0002_second ... (migrations.0001_initial, "
+ "migrations.0003_third)\n",
+ out.getvalue().lower(),
+ )
+
+ # Cleanup by unmigrating everything
+ call_command("migrate", "migrations", "zero", verbosity=0)
+
+ @override_settings(
+ MIGRATION_MODULES={"migrations": "migrations.test_migrations_plan"}
+ )
+ def test_migrate_plan(self):
+ """Tests migrate --plan output."""
+ out = io.StringIO()
+ # Show the plan up to the third migration.
+ call_command(
+ "migrate", "migrations", "0003", plan=True, stdout=out, no_color=True
+ )
+ self.assertEqual(
+ "Planned operations:\n"
+ "migrations.0001_initial\n"
+ " Create model Salamander\n"
+ " Raw Python operation -> Grow salamander tail.\n"
+ "migrations.0002_second\n"
+ " Create model Book\n"
+ " Raw SQL operation -> ['SELECT * FROM migrations_book']\n"
+ "migrations.0003_third\n"
+ " Create model Author\n"
+ " Raw SQL operation -> ['SELECT * FROM migrations_author']\n",
+ out.getvalue(),
+ )
+ try:
+ # Migrate to the third migration.
+ call_command("migrate", "migrations", "0003", verbosity=0)
+ out = io.StringIO()
+ # Show the plan for when there is nothing to apply.
+ call_command(
+ "migrate", "migrations", "0003", plan=True, stdout=out, no_color=True
+ )
+ self.assertEqual(
+ "Planned operations:\n No planned migration operations.\n",
+ out.getvalue(),
+ )
+ out = io.StringIO()
+ # Show the plan for reverse migration back to 0001.
+ call_command(
+ "migrate", "migrations", "0001", plan=True, stdout=out, no_color=True
+ )
+ self.assertEqual(
+ "Planned operations:\n"
+ "migrations.0003_third\n"
+ " Undo Create model Author\n"
+ " Raw SQL operation -> ['SELECT * FROM migrations_book']\n"
+ "migrations.0002_second\n"
+ " Undo Create model Book\n"
+ " Raw SQL operation -> ['SELECT * FROM migrations_salamand…\n",
+ out.getvalue(),
+ )
+ out = io.StringIO()
+ # Show the migration plan to fourth, with truncated details.
+ call_command(
+ "migrate", "migrations", "0004", plan=True, stdout=out, no_color=True
+ )
+ self.assertEqual(
+ "Planned operations:\n"
+ "migrations.0004_fourth\n"
+ " Raw SQL operation -> SELECT * FROM migrations_author WHE…\n",
+ out.getvalue(),
+ )
+ # Show the plan when an operation is irreversible.
+ # Migrate to the fourth migration.
+ call_command("migrate", "migrations", "0004", verbosity=0)
+ out = io.StringIO()
+ call_command(
+ "migrate", "migrations", "0003", plan=True, stdout=out, no_color=True
+ )
+ self.assertEqual(
+ "Planned operations:\n"
+ "migrations.0004_fourth\n"
+ " Raw SQL operation -> IRREVERSIBLE\n",
+ out.getvalue(),
+ )
+ out = io.StringIO()
+ call_command(
+ "migrate", "migrations", "0005", plan=True, stdout=out, no_color=True
+ )
+ # Operation is marked as irreversible only in the revert plan.
+ self.assertEqual(
+ "Planned operations:\n"
+ "migrations.0005_fifth\n"
+ " Raw Python operation\n"
+ " Raw Python operation\n"
+ " Raw Python operation -> Feed salamander.\n",
+ out.getvalue(),
+ )
+ call_command("migrate", "migrations", "0005", verbosity=0)
+ out = io.StringIO()
+ call_command(
+ "migrate", "migrations", "0004", plan=True, stdout=out, no_color=True
+ )
+ self.assertEqual(
+ "Planned operations:\n"
+ "migrations.0005_fifth\n"
+ " Raw Python operation -> IRREVERSIBLE\n"
+ " Raw Python operation -> IRREVERSIBLE\n"
+ " Raw Python operation\n",
+ out.getvalue(),
+ )
+ finally:
+ # Cleanup by unmigrating everything: fake the irreversible, then
+ # migrate all to zero.
+ call_command("migrate", "migrations", "0003", fake=True, verbosity=0)
+ call_command("migrate", "migrations", "zero", verbosity=0)
+
+ @override_settings(
+ MIGRATION_MODULES={"migrations": "migrations.test_migrations_empty"}
+ )
+ def test_showmigrations_no_migrations(self):
+ out = io.StringIO()
+ call_command("showmigrations", stdout=out, no_color=True)
+ self.assertEqual("migrations\n (no migrations)\n", out.getvalue().lower())
+
+ @override_settings(
+ INSTALLED_APPS=["migrations.migrations_test_apps.unmigrated_app"]
+ )
+ def test_showmigrations_unmigrated_app(self):
+ out = io.StringIO()
+ call_command("showmigrations", "unmigrated_app", stdout=out, no_color=True)
+ try:
+ self.assertEqual(
+ "unmigrated_app\n (no migrations)\n", out.getvalue().lower()
+ )
+ finally:
+ # unmigrated_app.SillyModel has a foreign key to
+ # 'migrations.Tribble', but that model is only defined in a
+ # migration, so the global app registry never sees it and the
+ # reference is left dangling. Remove it to avoid problems in
+ # subsequent tests.
+ apps._pending_operations.pop(("migrations", "tribble"), None)
+
+ @override_settings(
+ MIGRATION_MODULES={"migrations": "migrations.test_migrations_empty"}
+ )
+ def test_showmigrations_plan_no_migrations(self):
+ """
+ Tests --plan output of showmigrations command without migrations
+ """
+ out = io.StringIO()
+ call_command("showmigrations", format="plan", stdout=out, no_color=True)
+ self.assertEqual("(no migrations)\n", out.getvalue().lower())
+
+ out = io.StringIO()
+ call_command(
+ "showmigrations", format="plan", stdout=out, verbosity=2, no_color=True
+ )
+ self.assertEqual("(no migrations)\n", out.getvalue().lower())
+
+ @override_settings(
+ MIGRATION_MODULES={"migrations": "migrations.test_migrations_squashed_complex"}
+ )
+ def test_showmigrations_plan_squashed(self):
+ """
+ Tests --plan output of showmigrations command with squashed migrations.
+ """
+ out = io.StringIO()
+ call_command("showmigrations", format="plan", stdout=out)
+ self.assertEqual(
+ "[ ] migrations.1_auto\n"
+ "[ ] migrations.2_auto\n"
+ "[ ] migrations.3_squashed_5\n"
+ "[ ] migrations.6_auto\n"
+ "[ ] migrations.7_auto\n",
+ out.getvalue().lower(),
+ )
+
+ out = io.StringIO()
+ call_command("showmigrations", format="plan", stdout=out, verbosity=2)
+ self.assertEqual(
+ "[ ] migrations.1_auto\n"
+ "[ ] migrations.2_auto ... (migrations.1_auto)\n"
+ "[ ] migrations.3_squashed_5 ... (migrations.2_auto)\n"
+ "[ ] migrations.6_auto ... (migrations.3_squashed_5)\n"
+ "[ ] migrations.7_auto ... (migrations.6_auto)\n",
+ out.getvalue().lower(),
+ )
+
+ call_command("migrate", "migrations", "3_squashed_5", verbosity=0)
+
+ out = io.StringIO()
+ call_command("showmigrations", format="plan", stdout=out)
+ self.assertEqual(
+ "[x] migrations.1_auto\n"
+ "[x] migrations.2_auto\n"
+ "[x] migrations.3_squashed_5\n"
+ "[ ] migrations.6_auto\n"
+ "[ ] migrations.7_auto\n",
+ out.getvalue().lower(),
+ )
+
+ out = io.StringIO()
+ call_command("showmigrations", format="plan", stdout=out, verbosity=2)
+ self.assertEqual(
+ "[x] migrations.1_auto\n"
+ "[x] migrations.2_auto ... (migrations.1_auto)\n"
+ "[x] migrations.3_squashed_5 ... (migrations.2_auto)\n"
+ "[ ] migrations.6_auto ... (migrations.3_squashed_5)\n"
+ "[ ] migrations.7_auto ... (migrations.6_auto)\n",
+ out.getvalue().lower(),
+ )
+
+ @override_settings(
+ INSTALLED_APPS=[
+ "migrations.migrations_test_apps.mutate_state_b",
+ "migrations.migrations_test_apps.alter_fk.author_app",
+ "migrations.migrations_test_apps.alter_fk.book_app",
+ ]
+ )
+ def test_showmigrations_plan_single_app_label(self):
+ """
+ `showmigrations --plan app_label` output with a single app_label.
+ """
+ # Single app with no dependencies on other apps.
+ out = io.StringIO()
+ call_command("showmigrations", "mutate_state_b", format="plan", stdout=out)
+ self.assertEqual(
+ "[ ] mutate_state_b.0001_initial\n[ ] mutate_state_b.0002_add_field\n",
+ out.getvalue(),
+ )
+ # Single app with dependencies.
+ out = io.StringIO()
+ call_command("showmigrations", "author_app", format="plan", stdout=out)
+ self.assertEqual(
+ "[ ] author_app.0001_initial\n"
+ "[ ] book_app.0001_initial\n"
+ "[ ] author_app.0002_alter_id\n",
+ out.getvalue(),
+ )
+ # Some migrations already applied.
+ call_command("migrate", "author_app", "0001", verbosity=0)
+ out = io.StringIO()
+ call_command("showmigrations", "author_app", format="plan", stdout=out)
+ self.assertEqual(
+ "[X] author_app.0001_initial\n"
+ "[ ] book_app.0001_initial\n"
+ "[ ] author_app.0002_alter_id\n",
+ out.getvalue(),
+ )
+ # Cleanup by unmigrating author_app.
+ call_command("migrate", "author_app", "zero", verbosity=0)
+
+ @override_settings(
+ INSTALLED_APPS=[
+ "migrations.migrations_test_apps.mutate_state_b",
+ "migrations.migrations_test_apps.alter_fk.author_app",
+ "migrations.migrations_test_apps.alter_fk.book_app",
+ ]
+ )
+ def test_showmigrations_plan_multiple_app_labels(self):
+ """
+ `showmigrations --plan app_label` output with multiple app_labels.
+ """
+ # Multiple apps: author_app depends on book_app; mutate_state_b doesn't
+ # depend on other apps.
+ out = io.StringIO()
+ call_command(
+ "showmigrations", "mutate_state_b", "author_app", format="plan", stdout=out
+ )
+ self.assertEqual(
+ "[ ] author_app.0001_initial\n"
+ "[ ] book_app.0001_initial\n"
+ "[ ] author_app.0002_alter_id\n"
+ "[ ] mutate_state_b.0001_initial\n"
+ "[ ] mutate_state_b.0002_add_field\n",
+ out.getvalue(),
+ )
+ # Multiple apps: args order shouldn't matter (the same result is
+ # expected as above).
+ out = io.StringIO()
+ call_command(
+ "showmigrations", "author_app", "mutate_state_b", format="plan", stdout=out
+ )
+ self.assertEqual(
+ "[ ] author_app.0001_initial\n"
+ "[ ] book_app.0001_initial\n"
+ "[ ] author_app.0002_alter_id\n"
+ "[ ] mutate_state_b.0001_initial\n"
+ "[ ] mutate_state_b.0002_add_field\n",
+ out.getvalue(),
+ )
+
+ @override_settings(
+ INSTALLED_APPS=["migrations.migrations_test_apps.unmigrated_app"]
+ )
+ def test_showmigrations_plan_app_label_no_migrations(self):
+ out = io.StringIO()
+ call_command(
+ "showmigrations", "unmigrated_app", format="plan", stdout=out, no_color=True
+ )
+ try:
+ self.assertEqual("(no migrations)\n", out.getvalue())
+ finally:
+ # unmigrated_app.SillyModel has a foreign key to
+ # 'migrations.Tribble', but that model is only defined in a
+ # migration, so the global app registry never sees it and the
+ # reference is left dangling. Remove it to avoid problems in
+ # subsequent tests.
+ apps._pending_operations.pop(("migrations", "tribble"), None)
+
+ @override_settings(MIGRATION_MODULES={"migrations": "migrations.test_migrations"})
+ def test_sqlmigrate_forwards(self):
+ """
+ sqlmigrate outputs forward looking SQL.
+ """
+ out = io.StringIO()
+ call_command("sqlmigrate", "migrations", "0001", stdout=out)
+
+ lines = out.getvalue().splitlines()
+
+ if connection.features.can_rollback_ddl:
+ self.assertEqual(lines[0], connection.ops.start_transaction_sql())
+ self.assertEqual(lines[-1], connection.ops.end_transaction_sql())
+ lines = lines[1:-1]
+
+ self.assertEqual(
+ lines[:3],
+ [
+ "--",
+ "-- Create model Author",
+ "--",
+ ],
+ )
+ self.assertIn(
+ "create table %s" % connection.ops.quote_name("migrations_author").lower(),
+ lines[3].lower(),
+ )
+ pos = lines.index("--", 3)
+ self.assertEqual(
+ lines[pos : pos + 3],
+ [
+ "--",
+ "-- Create model Tribble",
+ "--",
+ ],
+ )
+ self.assertIn(
+ "create table %s" % connection.ops.quote_name("migrations_tribble").lower(),
+ lines[pos + 3].lower(),
+ )
+ pos = lines.index("--", pos + 3)
+ self.assertEqual(
+ lines[pos : pos + 3],
+ [
+ "--",
+ "-- Add field bool to tribble",
+ "--",
+ ],
+ )
+ pos = lines.index("--", pos + 3)
+ self.assertEqual(
+ lines[pos : pos + 3],
+ [
+ "--",
+ "-- Alter unique_together for author (1 constraint(s))",
+ "--",
+ ],
+ )
+
+ @override_settings(MIGRATION_MODULES={"migrations": "migrations.test_migrations"})
+ def test_sqlmigrate_backwards(self):
+ """
+ sqlmigrate outputs reverse looking SQL.
+ """
+ # Cannot generate the reverse SQL unless we've applied the migration.
+ call_command("migrate", "migrations", verbosity=0)
+
+ out = io.StringIO()
+ call_command("sqlmigrate", "migrations", "0001", stdout=out, backwards=True)
+
+ lines = out.getvalue().splitlines()
+ try:
+ if connection.features.can_rollback_ddl:
+ self.assertEqual(lines[0], connection.ops.start_transaction_sql())
+ self.assertEqual(lines[-1], connection.ops.end_transaction_sql())
+ lines = lines[1:-1]
+
+ self.assertEqual(
+ lines[:3],
+ [
+ "--",
+ "-- Alter unique_together for author (1 constraint(s))",
+ "--",
+ ],
+ )
+ pos = lines.index("--", 3)
+ self.assertEqual(
+ lines[pos : pos + 3],
+ [
+ "--",
+ "-- Add field bool to tribble",
+ "--",
+ ],
+ )
+ pos = lines.index("--", pos + 3)
+ self.assertEqual(
+ lines[pos : pos + 3],
+ [
+ "--",
+ "-- Create model Tribble",
+ "--",
+ ],
+ )
+ next_pos = lines.index("--", pos + 3)
+ drop_table_sql = (
+ "drop table %s"
+ % connection.ops.quote_name("migrations_tribble").lower()
+ )
+ for line in lines[pos + 3 : next_pos]:
+ if drop_table_sql in line.lower():
+ break
+ else:
+ self.fail("DROP TABLE (tribble) not found.")
+ pos = next_pos
+ self.assertEqual(
+ lines[pos : pos + 3],
+ [
+ "--",
+ "-- Create model Author",
+ "--",
+ ],
+ )
+ drop_table_sql = (
+ "drop table %s" % connection.ops.quote_name("migrations_author").lower()
+ )
+ for line in lines[pos + 3 :]:
+ if drop_table_sql in line.lower():
+ break
+ else:
+ self.fail("DROP TABLE (author) not found.")
+ finally:
+ # Unmigrate everything.
+ call_command("migrate", "migrations", "zero", verbosity=0)
+
+ @override_settings(
+ MIGRATION_MODULES={"migrations": "migrations.test_migrations_non_atomic"}
+ )
+ def test_sqlmigrate_for_non_atomic_migration(self):
+ """
+ Transaction wrappers aren't shown for non-atomic migrations.
+ """
+ out = io.StringIO()
+ call_command("sqlmigrate", "migrations", "0001", stdout=out)
+ output = out.getvalue().lower()
+ queries = [q.strip() for q in output.splitlines()]
+ if connection.ops.start_transaction_sql():
+ self.assertNotIn(connection.ops.start_transaction_sql().lower(), queries)
+ self.assertNotIn(connection.ops.end_transaction_sql().lower(), queries)
+
+ @override_settings(MIGRATION_MODULES={"migrations": "migrations.test_migrations"})
+ def test_sqlmigrate_for_non_transactional_databases(self):
+ """
+ Transaction wrappers aren't shown for databases that don't support
+ transactional DDL.
+ """
+ out = io.StringIO()
+ with mock.patch.object(connection.features, "can_rollback_ddl", False):
+ call_command("sqlmigrate", "migrations", "0001", stdout=out)
+ output = out.getvalue().lower()
+ queries = [q.strip() for q in output.splitlines()]
+ start_transaction_sql = connection.ops.start_transaction_sql()
+ if start_transaction_sql:
+ self.assertNotIn(start_transaction_sql.lower(), queries)
+ self.assertNotIn(connection.ops.end_transaction_sql().lower(), queries)
+
+ @override_settings(
+ MIGRATION_MODULES={"migrations": "migrations.test_migrations_squashed"}
+ )
+ def test_sqlmigrate_ambiguous_prefix_squashed_migrations(self):
+ msg = (
+ "More than one migration matches '0001' in app 'migrations'. "
+ "Please be more specific."
+ )
+ with self.assertRaisesMessage(CommandError, msg):
+ call_command("sqlmigrate", "migrations", "0001")
+
+ @override_settings(
+ MIGRATION_MODULES={"migrations": "migrations.test_migrations_squashed"}
+ )
+ def test_sqlmigrate_squashed_migration(self):
+ out = io.StringIO()
+ call_command("sqlmigrate", "migrations", "0001_squashed_0002", stdout=out)
+ output = out.getvalue().lower()
+ self.assertIn("-- create model author", output)
+ self.assertIn("-- create model book", output)
+ self.assertNotIn("-- create model tribble", output)
+
+ @override_settings(
+ MIGRATION_MODULES={"migrations": "migrations.test_migrations_squashed"}
+ )
+ def test_sqlmigrate_replaced_migration(self):
+ out = io.StringIO()
+ call_command("sqlmigrate", "migrations", "0001_initial", stdout=out)
+ output = out.getvalue().lower()
+ self.assertIn("-- create model author", output)
+ self.assertIn("-- create model tribble", output)
+
+ @override_settings(
+ MIGRATION_MODULES={"migrations": "migrations.test_migrations_no_operations"}
+ )
+ def test_sqlmigrate_no_operations(self):
+ err = io.StringIO()
+ call_command("sqlmigrate", "migrations", "0001_initial", stderr=err)
+ self.assertEqual(err.getvalue(), "No operations found.\n")
+
+ @override_settings(
+ MIGRATION_MODULES={"migrations": "migrations.test_migrations_noop"}
+ )
+ def test_sqlmigrate_noop(self):
+ out = io.StringIO()
+ call_command("sqlmigrate", "migrations", "0001", stdout=out)
+ lines = out.getvalue().splitlines()
+
+ if connection.features.can_rollback_ddl:
+ lines = lines[1:-1]
+ self.assertEqual(
+ lines,
+ [
+ "--",
+ "-- Raw SQL operation",
+ "--",
+ "-- (no-op)",
+ ],
+ )
+
+ @override_settings(
+ MIGRATION_MODULES={"migrations": "migrations.test_migrations_manual_porting"}
+ )
+ def test_sqlmigrate_unrepresentable(self):
+ out = io.StringIO()
+ call_command("sqlmigrate", "migrations", "0002", stdout=out)
+ lines = out.getvalue().splitlines()
+
+ if connection.features.can_rollback_ddl:
+ lines = lines[1:-1]
+ self.assertEqual(
+ lines,
+ [
+ "--",
+ "-- Raw Python operation",
+ "--",
+ "-- THIS OPERATION CANNOT BE WRITTEN AS SQL",
+ ],
+ )
+
+ @override_settings(
+ INSTALLED_APPS=[
+ "migrations.migrations_test_apps.migrated_app",
+ "migrations.migrations_test_apps.migrated_unapplied_app",
+ "migrations.migrations_test_apps.unmigrated_app",
+ ],
+ )
+ def test_regression_22823_unmigrated_fk_to_migrated_model(self):
+ """
+ Assuming you have 3 apps, `A`, `B`, and `C`, such that:
+
+ * `A` has migrations
+ * `B` has a migration we want to apply
+ * `C` has no migrations, but has an FK to `A`
+
+ When we try to migrate "B", an exception occurs because the
+ "B" was not included in the ProjectState that is used to detect
+ soft-applied migrations (#22823).
+ """
+ call_command("migrate", "migrated_unapplied_app", verbosity=0)
+
+ # unmigrated_app.SillyModel has a foreign key to 'migrations.Tribble',
+ # but that model is only defined in a migration, so the global app
+ # registry never sees it and the reference is left dangling. Remove it
+ # to avoid problems in subsequent tests.
+ apps._pending_operations.pop(("migrations", "tribble"), None)
+
+ @override_settings(
+ INSTALLED_APPS=["migrations.migrations_test_apps.unmigrated_app_syncdb"]
+ )
+ def test_migrate_syncdb_deferred_sql_executed_with_schemaeditor(self):
+ """
+ For an app without migrations, editor.execute() is used for executing
+ the syncdb deferred SQL.
+ """
+ stdout = io.StringIO()
+ with mock.patch.object(BaseDatabaseSchemaEditor, "execute") as execute:
+ call_command(
+ "migrate", run_syncdb=True, verbosity=1, stdout=stdout, no_color=True
+ )
+ create_table_count = len(
+ [call for call in execute.mock_calls if "CREATE TABLE" in str(call)]
+ )
+ self.assertEqual(create_table_count, 2)
+ # There's at least one deferred SQL for creating the foreign key
+ # index.
+ self.assertGreater(len(execute.mock_calls), 2)
+ stdout = stdout.getvalue()
+ self.assertIn("Synchronize unmigrated apps: unmigrated_app_syncdb", stdout)
+ self.assertIn("Creating tables...", stdout)
+ table_name = truncate_name(
+ "unmigrated_app_syncdb_classroom", connection.ops.max_name_length()
+ )
+ self.assertIn("Creating table %s" % table_name, stdout)
+
+ @override_settings(MIGRATION_MODULES={"migrations": "migrations.test_migrations"})
+ def test_migrate_syncdb_app_with_migrations(self):
+ msg = "Can't use run_syncdb with app 'migrations' as it has migrations."
+ with self.assertRaisesMessage(CommandError, msg):
+ call_command("migrate", "migrations", run_syncdb=True, verbosity=0)
+
+ @override_settings(
+ INSTALLED_APPS=[
+ "migrations.migrations_test_apps.unmigrated_app_syncdb",
+ "migrations.migrations_test_apps.unmigrated_app_simple",
+ ]
+ )
+ def test_migrate_syncdb_app_label(self):
+ """
+ Running migrate --run-syncdb with an app_label only creates tables for
+ the specified app.
+ """
+ stdout = io.StringIO()
+ with mock.patch.object(BaseDatabaseSchemaEditor, "execute") as execute:
+ call_command(
+ "migrate", "unmigrated_app_syncdb", run_syncdb=True, stdout=stdout
+ )
+ create_table_count = len(
+ [call for call in execute.mock_calls if "CREATE TABLE" in str(call)]
+ )
+ self.assertEqual(create_table_count, 2)
+ self.assertGreater(len(execute.mock_calls), 2)
+ self.assertIn(
+ "Synchronize unmigrated app: unmigrated_app_syncdb", stdout.getvalue()
+ )
+
+ @override_settings(
+ MIGRATION_MODULES={"migrations": "migrations.test_migrations_squashed"}
+ )
+ def test_migrate_record_replaced(self):
+ """
+ Running a single squashed migration should record all of the original
+ replaced migrations as run.
+ """
+ recorder = MigrationRecorder(connection)
+ out = io.StringIO()
+ call_command("migrate", "migrations", verbosity=0)
+ call_command("showmigrations", "migrations", stdout=out, no_color=True)
+ self.assertEqual(
+ "migrations\n [x] 0001_squashed_0002 (2 squashed migrations)\n",
+ out.getvalue().lower(),
+ )
+ applied_migrations = recorder.applied_migrations()
+ self.assertIn(("migrations", "0001_initial"), applied_migrations)
+ self.assertIn(("migrations", "0002_second"), applied_migrations)
+ self.assertIn(("migrations", "0001_squashed_0002"), applied_migrations)
+ # Rollback changes
+ call_command("migrate", "migrations", "zero", verbosity=0)
+
+ @override_settings(
+ MIGRATION_MODULES={"migrations": "migrations.test_migrations_squashed"}
+ )
+ def test_migrate_record_squashed(self):
+ """
+ Running migrate for a squashed migration should record as run
+ if all of the replaced migrations have been run (#25231).
+ """
+ recorder = MigrationRecorder(connection)
+ recorder.record_applied("migrations", "0001_initial")
+ recorder.record_applied("migrations", "0002_second")
+ out = io.StringIO()
+ call_command("showmigrations", "migrations", stdout=out, no_color=True)
+ self.assertEqual(
+ "migrations\n"
+ " [-] 0001_squashed_0002 (2 squashed migrations) "
+ "run 'manage.py migrate' to finish recording.\n",
+ out.getvalue().lower(),
+ )
+
+ out = io.StringIO()
+ call_command("migrate", "migrations", verbosity=0)
+ call_command("showmigrations", "migrations", stdout=out, no_color=True)
+ self.assertEqual(
+ "migrations\n [x] 0001_squashed_0002 (2 squashed migrations)\n",
+ out.getvalue().lower(),
+ )
+ self.assertIn(
+ ("migrations", "0001_squashed_0002"), recorder.applied_migrations()
+ )
+ # No changes were actually applied so there is nothing to rollback
+
+ def test_migrate_partially_applied_squashed_migration(self):
+ """
+ Migrating to a squashed migration specified by name should succeed
+ even if it is partially applied.
+ """
+ with self.temporary_migration_module(module="migrations.test_migrations"):
+ recorder = MigrationRecorder(connection)
+ try:
+ call_command("migrate", "migrations", "0001_initial", verbosity=0)
+ call_command(
+ "squashmigrations",
+ "migrations",
+ "0002",
+ interactive=False,
+ verbosity=0,
+ )
+ call_command(
+ "migrate",
+ "migrations",
+ "0001_squashed_0002_second",
+ verbosity=0,
+ )
+ applied_migrations = recorder.applied_migrations()
+ self.assertIn(("migrations", "0002_second"), applied_migrations)
+ finally:
+ # Unmigrate everything.
+ call_command("migrate", "migrations", "zero", verbosity=0)
+
+ @override_settings(
+ MIGRATION_MODULES={"migrations": "migrations.test_migrations_squashed"}
+ )
+ def test_migrate_backward_to_squashed_migration(self):
+ try:
+ call_command("migrate", "migrations", "0001_squashed_0002", verbosity=0)
+ self.assertTableExists("migrations_author")
+ self.assertTableExists("migrations_book")
+ call_command("migrate", "migrations", "0001_initial", verbosity=0)
+ self.assertTableExists("migrations_author")
+ self.assertTableNotExists("migrations_book")
+ finally:
+ # Unmigrate everything.
+ call_command("migrate", "migrations", "zero", verbosity=0)
+
+ @override_settings(MIGRATION_MODULES={"migrations": "migrations.test_migrations"})
+ def test_migrate_inconsistent_history(self):
+ """
+ Running migrate with some migrations applied before their dependencies
+ should not be allowed.
+ """
+ recorder = MigrationRecorder(connection)
+ recorder.record_applied("migrations", "0002_second")
+ msg = (
+ "Migration migrations.0002_second is applied before its dependency "
+ "migrations.0001_initial"
+ )
+ with self.assertRaisesMessage(InconsistentMigrationHistory, msg):
+ call_command("migrate")
+ applied_migrations = recorder.applied_migrations()
+ self.assertNotIn(("migrations", "0001_initial"), applied_migrations)
+
+ @override_settings(
+ INSTALLED_APPS=[
+ "migrations.migrations_test_apps.migrated_unapplied_app",
+ "migrations.migrations_test_apps.migrated_app",
+ ]
+ )
+ def test_migrate_not_reflected_changes(self):
+ class NewModel1(models.Model):
+ class Meta:
+ app_label = "migrated_app"
+
+ class NewModel2(models.Model):
+ class Meta:
+ app_label = "migrated_unapplied_app"
+
+ out = io.StringIO()
+ try:
+ call_command("migrate", verbosity=0)
+ call_command("migrate", stdout=out, no_color=True)
+ self.assertEqual(
+ "operations to perform:\n"
+ " apply all migrations: migrated_app, migrated_unapplied_app\n"
+ "running migrations:\n"
+ " no migrations to apply.\n"
+ " your models in app(s): 'migrated_app', "
+ "'migrated_unapplied_app' have changes that are not yet "
+ "reflected in a migration, and so won't be applied.\n"
+ " run 'manage.py makemigrations' to make new migrations, and "
+ "then re-run 'manage.py migrate' to apply them.\n",
+ out.getvalue().lower(),
+ )
+ finally:
+ # Unmigrate everything.
+ call_command("migrate", "migrated_app", "zero", verbosity=0)
+ call_command("migrate", "migrated_unapplied_app", "zero", verbosity=0)
+
+ @override_settings(
+ MIGRATION_MODULES={
+ "migrations": "migrations.test_migrations_squashed_no_replaces",
+ }
+ )
+ def test_migrate_prune(self):
+ """
+ With prune=True, references to migration files deleted from the
+ migrations module (such as after being squashed) are removed from the
+ django_migrations table.
+ """
+ recorder = MigrationRecorder(connection)
+ recorder.record_applied("migrations", "0001_initial")
+ recorder.record_applied("migrations", "0002_second")
+ recorder.record_applied("migrations", "0001_squashed_0002")
+ out = io.StringIO()
+ try:
+ call_command("migrate", "migrations", prune=True, stdout=out, no_color=True)
+ self.assertEqual(
+ out.getvalue(),
+ "Pruning migrations:\n"
+ " Pruning migrations.0001_initial OK\n"
+ " Pruning migrations.0002_second OK\n",
+ )
+ applied_migrations = [
+ migration
+ for migration in recorder.applied_migrations()
+ if migration[0] == "migrations"
+ ]
+ self.assertEqual(applied_migrations, [("migrations", "0001_squashed_0002")])
+ finally:
+ recorder.record_unapplied("migrations", "0001_initial")
+ recorder.record_unapplied("migrations", "0001_second")
+ recorder.record_unapplied("migrations", "0001_squashed_0002")
+
+ @override_settings(
+ MIGRATION_MODULES={"migrations": "migrations.test_migrations_squashed"}
+ )
+ def test_prune_deleted_squashed_migrations_in_replaces(self):
+ out = io.StringIO()
+ with self.temporary_migration_module(
+ module="migrations.test_migrations_squashed"
+ ) as migration_dir:
+ try:
+ call_command("migrate", "migrations", verbosity=0)
+ # Delete the replaced migrations.
+ os.remove(os.path.join(migration_dir, "0001_initial.py"))
+ os.remove(os.path.join(migration_dir, "0002_second.py"))
+ # --prune cannot be used before removing the "replaces"
+ # attribute.
+ call_command(
+ "migrate",
+ "migrations",
+ prune=True,
+ stdout=out,
+ no_color=True,
+ )
+ self.assertEqual(
+ out.getvalue(),
+ "Pruning migrations:\n"
+ " Cannot use --prune because the following squashed "
+ "migrations have their 'replaces' attributes and may not "
+ "be recorded as applied:\n"
+ " migrations.0001_squashed_0002\n"
+ " Re-run 'manage.py migrate' if they are not marked as "
+ "applied, and remove 'replaces' attributes in their "
+ "Migration classes.\n",
+ )
+ finally:
+ # Unmigrate everything.
+ call_command("migrate", "migrations", "zero", verbosity=0)
+
+ @override_settings(
+ MIGRATION_MODULES={"migrations": "migrations.test_migrations_squashed"}
+ )
+ def test_prune_no_migrations_to_prune(self):
+ out = io.StringIO()
+ call_command("migrate", "migrations", prune=True, stdout=out, no_color=True)
+ self.assertEqual(
+ out.getvalue(),
+ "Pruning migrations:\n No migrations to prune.\n",
+ )
+ out = io.StringIO()
+ call_command(
+ "migrate",
+ "migrations",
+ prune=True,
+ stdout=out,
+ no_color=True,
+ verbosity=0,
+ )
+ self.assertEqual(out.getvalue(), "")
+
+ def test_prune_no_app_label(self):
+ msg = "Migrations can be pruned only when an app is specified."
+ with self.assertRaisesMessage(CommandError, msg):
+ call_command("migrate", prune=True)
+
+
+class MakeMigrationsTests(MigrationTestBase):
+ """
+ Tests running the makemigrations command.
+ """
+
+ def setUp(self):
+ super().setUp()
+ self._old_models = apps.app_configs["migrations"].models.copy()
+
+ def tearDown(self):
+ apps.app_configs["migrations"].models = self._old_models
+ apps.all_models["migrations"] = self._old_models
+ apps.clear_cache()
+ super().tearDown()
+
+ def test_files_content(self):
+ self.assertTableNotExists("migrations_unicodemodel")
+ apps.register_model("migrations", UnicodeModel)
+ with self.temporary_migration_module() as migration_dir:
+ call_command("makemigrations", "migrations", verbosity=0)
+
+ # Check for empty __init__.py file in migrations folder
+ init_file = os.path.join(migration_dir, "__init__.py")
+ self.assertTrue(os.path.exists(init_file))
+
+ with open(init_file) as fp:
+ content = fp.read()
+ self.assertEqual(content, "")
+
+ # Check for existing 0001_initial.py file in migration folder
+ initial_file = os.path.join(migration_dir, "0001_initial.py")
+ self.assertTrue(os.path.exists(initial_file))
+
+ with open(initial_file, encoding="utf-8") as fp:
+ content = fp.read()
+ self.assertIn("migrations.CreateModel", content)
+ self.assertIn("initial = True", content)
+
+ self.assertIn("úñí©óðé µóðéø", content) # Meta.verbose_name
+ self.assertIn("úñí©óðé µóðéøß", content) # Meta.verbose_name_plural
+ self.assertIn("ÚÑÍ¢ÓÐÉ", content) # title.verbose_name
+ self.assertIn("“Ðjáñgó”", content) # title.default
+
+ def test_makemigrations_order(self):
+ """
+ makemigrations should recognize number-only migrations (0001.py).
+ """
+ module = "migrations.test_migrations_order"
+ with self.temporary_migration_module(module=module) as migration_dir:
+ if hasattr(importlib, "invalidate_caches"):
+ # importlib caches os.listdir() on some platforms like macOS
+ # (#23850).
+ importlib.invalidate_caches()
+ call_command(
+ "makemigrations", "migrations", "--empty", "-n", "a", "-v", "0"
+ )
+ self.assertTrue(os.path.exists(os.path.join(migration_dir, "0002_a.py")))
+
+ def test_makemigrations_empty_connections(self):
+ empty_connections = ConnectionHandler({"default": {}})
+ with mock.patch(
+ "django.core.management.commands.makemigrations.connections",
+ new=empty_connections,
+ ):
+ # with no apps
+ out = io.StringIO()
+ call_command("makemigrations", stdout=out)
+ self.assertIn("No changes detected", out.getvalue())
+ # with an app
+ with self.temporary_migration_module() as migration_dir:
+ call_command("makemigrations", "migrations", verbosity=0)
+ init_file = os.path.join(migration_dir, "__init__.py")
+ self.assertTrue(os.path.exists(init_file))
+
+ @override_settings(INSTALLED_APPS=["migrations", "migrations2"])
+ def test_makemigrations_consistency_checks_respect_routers(self):
+ """
+ The history consistency checks in makemigrations respect
+ settings.DATABASE_ROUTERS.
+ """
+
+ def patched_has_table(migration_recorder):
+ if migration_recorder.connection is connections["other"]:
+ raise Exception("Other connection")
+ else:
+ return mock.DEFAULT
+
+ self.assertTableNotExists("migrations_unicodemodel")
+ apps.register_model("migrations", UnicodeModel)
+ with mock.patch.object(
+ MigrationRecorder, "has_table", autospec=True, side_effect=patched_has_table
+ ) as has_table:
+ with self.temporary_migration_module() as migration_dir:
+ call_command("makemigrations", "migrations", verbosity=0)
+ initial_file = os.path.join(migration_dir, "0001_initial.py")
+ self.assertTrue(os.path.exists(initial_file))
+ self.assertEqual(has_table.call_count, 1) # 'default' is checked
+
+ # Router says not to migrate 'other' so consistency shouldn't
+ # be checked.
+ with self.settings(DATABASE_ROUTERS=["migrations.routers.TestRouter"]):
+ call_command("makemigrations", "migrations", verbosity=0)
+ self.assertEqual(has_table.call_count, 2) # 'default' again
+
+ # With a router that doesn't prohibit migrating 'other',
+ # consistency is checked.
+ with self.settings(
+ DATABASE_ROUTERS=["migrations.routers.DefaultOtherRouter"]
+ ):
+ with self.assertRaisesMessage(Exception, "Other connection"):
+ call_command("makemigrations", "migrations", verbosity=0)
+ self.assertEqual(has_table.call_count, 4) # 'default' and 'other'
+
+ # With a router that doesn't allow migrating on any database,
+ # no consistency checks are made.
+ with self.settings(DATABASE_ROUTERS=["migrations.routers.TestRouter"]):
+ with mock.patch.object(
+ TestRouter, "allow_migrate", return_value=False
+ ) as allow_migrate:
+ call_command("makemigrations", "migrations", verbosity=0)
+ allow_migrate.assert_any_call(
+ "other", "migrations", model_name="UnicodeModel"
+ )
+ # allow_migrate() is called with the correct arguments.
+ self.assertGreater(len(allow_migrate.mock_calls), 0)
+ called_aliases = set()
+ for mock_call in allow_migrate.mock_calls:
+ _, call_args, call_kwargs = mock_call
+ connection_alias, app_name = call_args
+ called_aliases.add(connection_alias)
+ # Raises an error if invalid app_name/model_name occurs.
+ apps.get_app_config(app_name).get_model(call_kwargs["model_name"])
+ self.assertEqual(called_aliases, set(connections))
+ self.assertEqual(has_table.call_count, 4)
+
+ def test_failing_migration(self):
+ # If a migration fails to serialize, it shouldn't generate an empty file. #21280
+ apps.register_model("migrations", UnserializableModel)
+
+ with self.temporary_migration_module() as migration_dir:
+ with self.assertRaisesMessage(ValueError, "Cannot serialize"):
+ call_command("makemigrations", "migrations", verbosity=0)
+
+ initial_file = os.path.join(migration_dir, "0001_initial.py")
+ self.assertFalse(os.path.exists(initial_file))
+
+ def test_makemigrations_conflict_exit(self):
+ """
+ makemigrations exits if it detects a conflict.
+ """
+ with self.temporary_migration_module(
+ module="migrations.test_migrations_conflict"
+ ):
+ with self.assertRaises(CommandError) as context:
+ call_command("makemigrations")
+ self.assertEqual(
+ str(context.exception),
+ "Conflicting migrations detected; multiple leaf nodes in the "
+ "migration graph: (0002_conflicting_second, 0002_second in "
+ "migrations).\n"
+ "To fix them run 'python manage.py makemigrations --merge'",
+ )
+
+ def test_makemigrations_merge_no_conflict(self):
+ """
+ makemigrations exits if in merge mode with no conflicts.
+ """
+ out = io.StringIO()
+ with self.temporary_migration_module(module="migrations.test_migrations"):
+ call_command("makemigrations", merge=True, stdout=out)
+ self.assertIn("No conflicts detected to merge.", out.getvalue())
+
+ def test_makemigrations_empty_no_app_specified(self):
+ """
+ makemigrations exits if no app is specified with 'empty' mode.
+ """
+ msg = "You must supply at least one app label when using --empty."
+ with self.assertRaisesMessage(CommandError, msg):
+ call_command("makemigrations", empty=True)
+
+ def test_makemigrations_empty_migration(self):
+ """
+ makemigrations properly constructs an empty migration.
+ """
+ with self.temporary_migration_module() as migration_dir:
+ call_command("makemigrations", "migrations", empty=True, verbosity=0)
+
+ # Check for existing 0001_initial.py file in migration folder
+ initial_file = os.path.join(migration_dir, "0001_initial.py")
+ self.assertTrue(os.path.exists(initial_file))
+
+ with open(initial_file, encoding="utf-8") as fp:
+ content = fp.read()
+
+ # Remove all whitespace to check for empty dependencies and operations
+ content = content.replace(" ", "")
+ self.assertIn(
+ "dependencies=[]" if HAS_BLACK else "dependencies=[\n]", content
+ )
+ self.assertIn(
+ "operations=[]" if HAS_BLACK else "operations=[\n]", content
+ )
+
+ @override_settings(MIGRATION_MODULES={"migrations": None})
+ def test_makemigrations_disabled_migrations_for_app(self):
+ """
+ makemigrations raises a nice error when migrations are disabled for an
+ app.
+ """
+ msg = (
+ "Django can't create migrations for app 'migrations' because migrations "
+ "have been disabled via the MIGRATION_MODULES setting."
+ )
+ with self.assertRaisesMessage(ValueError, msg):
+ call_command("makemigrations", "migrations", empty=True, verbosity=0)
+
+ def test_makemigrations_no_changes_no_apps(self):
+ """
+ makemigrations exits when there are no changes and no apps are specified.
+ """
+ out = io.StringIO()
+ call_command("makemigrations", stdout=out)
+ self.assertIn("No changes detected", out.getvalue())
+
+ def test_makemigrations_no_changes(self):
+ """
+ makemigrations exits when there are no changes to an app.
+ """
+ out = io.StringIO()
+ with self.temporary_migration_module(
+ module="migrations.test_migrations_no_changes"
+ ):
+ call_command("makemigrations", "migrations", stdout=out)
+ self.assertIn("No changes detected in app 'migrations'", out.getvalue())
+
+ def test_makemigrations_no_apps_initial(self):
+ """
+ makemigrations should detect initial is needed on empty migration
+ modules if no app provided.
+ """
+ out = io.StringIO()
+ with self.temporary_migration_module(module="migrations.test_migrations_empty"):
+ call_command("makemigrations", stdout=out)
+ self.assertIn("0001_initial.py", out.getvalue())
+
+ def test_makemigrations_no_init(self):
+ """Migration directories without an __init__.py file are allowed."""
+ out = io.StringIO()
+ with self.temporary_migration_module(
+ module="migrations.test_migrations_no_init"
+ ):
+ call_command("makemigrations", stdout=out)
+ self.assertIn("0001_initial.py", out.getvalue())
+
+ def test_makemigrations_migrations_announce(self):
+ """
+ makemigrations announces the migration at the default verbosity level.
+ """
+ out = io.StringIO()
+ with self.temporary_migration_module():
+ call_command("makemigrations", "migrations", stdout=out)
+ self.assertIn("Migrations for 'migrations'", out.getvalue())
+
+ def test_makemigrations_no_common_ancestor(self):
+ """
+ makemigrations fails to merge migrations with no common ancestor.
+ """
+ with self.assertRaises(ValueError) as context:
+ with self.temporary_migration_module(
+ module="migrations.test_migrations_no_ancestor"
+ ):
+ call_command("makemigrations", "migrations", merge=True)
+ exception_message = str(context.exception)
+ self.assertIn("Could not find common ancestor of", exception_message)
+ self.assertIn("0002_second", exception_message)
+ self.assertIn("0002_conflicting_second", exception_message)
+
+ def test_makemigrations_interactive_reject(self):
+ """
+ makemigrations enters and exits interactive mode properly.
+ """
+ # Monkeypatch interactive questioner to auto reject
+ with mock.patch("builtins.input", mock.Mock(return_value="N")):
+ with self.temporary_migration_module(
+ module="migrations.test_migrations_conflict"
+ ) as migration_dir:
+ with captured_stdout():
+ call_command(
+ "makemigrations",
+ "migrations",
+ name="merge",
+ merge=True,
+ interactive=True,
+ verbosity=0,
+ )
+ merge_file = os.path.join(migration_dir, "0003_merge.py")
+ self.assertFalse(os.path.exists(merge_file))
+
+ def test_makemigrations_interactive_accept(self):
+ """
+ makemigrations enters interactive mode and merges properly.
+ """
+ # Monkeypatch interactive questioner to auto accept
+ with mock.patch("builtins.input", mock.Mock(return_value="y")):
+ out = io.StringIO()
+ with self.temporary_migration_module(
+ module="migrations.test_migrations_conflict"
+ ) as migration_dir:
+ call_command(
+ "makemigrations",
+ "migrations",
+ name="merge",
+ merge=True,
+ interactive=True,
+ stdout=out,
+ )
+ merge_file = os.path.join(migration_dir, "0003_merge.py")
+ self.assertTrue(os.path.exists(merge_file))
+ self.assertIn("Created new merge migration", out.getvalue())
+
+ def test_makemigrations_default_merge_name(self):
+ out = io.StringIO()
+ with self.temporary_migration_module(
+ module="migrations.test_migrations_conflict"
+ ) as migration_dir:
+ call_command(
+ "makemigrations",
+ "migrations",
+ merge=True,
+ interactive=False,
+ stdout=out,
+ )
+ merge_file = os.path.join(
+ migration_dir,
+ "0003_merge_0002_conflicting_second_0002_second.py",
+ )
+ self.assertIs(os.path.exists(merge_file), True)
+ with open(merge_file, encoding="utf-8") as fp:
+ content = fp.read()
+ if HAS_BLACK:
+ target_str = '("migrations", "0002_conflicting_second")'
+ else:
+ target_str = "('migrations', '0002_conflicting_second')"
+ self.assertIn(target_str, content)
+ self.assertIn("Created new merge migration %s" % merge_file, out.getvalue())
+
+ @mock.patch("django.db.migrations.utils.datetime")
+ def test_makemigrations_auto_merge_name(self, mock_datetime):
+ mock_datetime.datetime.now.return_value = datetime.datetime(2016, 1, 2, 3, 4)
+ with mock.patch("builtins.input", mock.Mock(return_value="y")):
+ out = io.StringIO()
+ with self.temporary_migration_module(
+ module="migrations.test_migrations_conflict_long_name"
+ ) as migration_dir:
+ call_command(
+ "makemigrations",
+ "migrations",
+ merge=True,
+ interactive=True,
+ stdout=out,
+ )
+ merge_file = os.path.join(migration_dir, "0003_merge_20160102_0304.py")
+ self.assertTrue(os.path.exists(merge_file))
+ self.assertIn("Created new merge migration", out.getvalue())
+
+ def test_makemigrations_non_interactive_not_null_addition(self):
+ """
+ Non-interactive makemigrations fails when a default is missing on a
+ new not-null field.
+ """
+
+ class SillyModel(models.Model):
+ silly_field = models.BooleanField(default=False)
+ silly_int = models.IntegerField()
+
+ class Meta:
+ app_label = "migrations"
+
+ with self.assertRaises(SystemExit):
+ with self.temporary_migration_module(
+ module="migrations.test_migrations_no_default"
+ ):
+ with captured_stdout() as out:
+ call_command("makemigrations", "migrations", interactive=False)
+ self.assertIn(
+ "Field 'silly_int' on model 'sillymodel' not migrated: it is "
+ "impossible to add a non-nullable field without specifying a "
+ "default.",
+ out.getvalue(),
+ )
+
+ def test_makemigrations_interactive_not_null_addition(self):
+ """
+ makemigrations messages when adding a NOT NULL field in interactive
+ mode.
+ """
+
+ class Author(models.Model):
+ silly_field = models.BooleanField(null=False)
+
+ class Meta:
+ app_label = "migrations"
+
+ input_msg = (
+ "It is impossible to add a non-nullable field 'silly_field' to "
+ "author without specifying a default. This is because the "
+ "database needs something to populate existing rows.\n"
+ "Please select a fix:\n"
+ " 1) Provide a one-off default now (will be set on all existing "
+ "rows with a null value for this column)\n"
+ " 2) Quit and manually define a default value in models.py."
+ )
+ with self.temporary_migration_module(module="migrations.test_migrations"):
+ # 2 - quit.
+ with mock.patch("builtins.input", return_value="2"):
+ with captured_stdout() as out, self.assertRaises(SystemExit):
+ call_command("makemigrations", "migrations", interactive=True)
+ self.assertIn(input_msg, out.getvalue())
+ # 1 - provide a default.
+ with mock.patch("builtins.input", return_value="1"):
+ with captured_stdout() as out:
+ call_command("makemigrations", "migrations", interactive=True)
+ output = out.getvalue()
+ self.assertIn(input_msg, output)
+ self.assertIn("Please enter the default value as valid Python.", output)
+ self.assertIn(
+ "The datetime and django.utils.timezone modules are "
+ "available, so it is possible to provide e.g. timezone.now as "
+ "a value",
+ output,
+ )
+ self.assertIn("Type 'exit' to exit this prompt", output)
+
+ def test_makemigrations_non_interactive_not_null_alteration(self):
+ """
+ Non-interactive makemigrations fails when a default is missing on a
+ field changed to not-null.
+ """
+
+ class Author(models.Model):
+ name = models.CharField(max_length=255)
+ slug = models.SlugField()
+ age = models.IntegerField(default=0)
+
+ class Meta:
+ app_label = "migrations"
+
+ with self.temporary_migration_module(module="migrations.test_migrations"):
+ with captured_stdout() as out:
+ call_command("makemigrations", "migrations", interactive=False)
+ self.assertIn("Alter field slug on author", out.getvalue())
+ self.assertIn(
+ "Field 'slug' on model 'author' given a default of NOT PROVIDED "
+ "and must be corrected.",
+ out.getvalue(),
+ )
+
+ def test_makemigrations_interactive_not_null_alteration(self):
+ """
+ makemigrations messages when changing a NULL field to NOT NULL in
+ interactive mode.
+ """
+
+ class Author(models.Model):
+ slug = models.SlugField(null=False)
+
+ class Meta:
+ app_label = "migrations"
+
+ input_msg = (
+ "It is impossible to change a nullable field 'slug' on author to "
+ "non-nullable without providing a default. This is because the "
+ "database needs something to populate existing rows.\n"
+ "Please select a fix:\n"
+ " 1) Provide a one-off default now (will be set on all existing "
+ "rows with a null value for this column)\n"
+ " 2) Ignore for now. Existing rows that contain NULL values will "
+ "have to be handled manually, for example with a RunPython or "
+ "RunSQL operation.\n"
+ " 3) Quit and manually define a default value in models.py."
+ )
+ with self.temporary_migration_module(module="migrations.test_migrations"):
+ # No message appears if --dry-run.
+ with captured_stdout() as out:
+ call_command(
+ "makemigrations",
+ "migrations",
+ interactive=True,
+ dry_run=True,
+ )
+ self.assertNotIn(input_msg, out.getvalue())
+ # 3 - quit.
+ with mock.patch("builtins.input", return_value="3"):
+ with captured_stdout() as out, self.assertRaises(SystemExit):
+ call_command("makemigrations", "migrations", interactive=True)
+ self.assertIn(input_msg, out.getvalue())
+ # 1 - provide a default.
+ with mock.patch("builtins.input", return_value="1"):
+ with captured_stdout() as out:
+ call_command("makemigrations", "migrations", interactive=True)
+ output = out.getvalue()
+ self.assertIn(input_msg, output)
+ self.assertIn("Please enter the default value as valid Python.", output)
+ self.assertIn(
+ "The datetime and django.utils.timezone modules are "
+ "available, so it is possible to provide e.g. timezone.now as "
+ "a value",
+ output,
+ )
+ self.assertIn("Type 'exit' to exit this prompt", output)
+
+ def test_makemigrations_non_interactive_no_model_rename(self):
+ """
+ makemigrations adds and removes a possible model rename in
+ non-interactive mode.
+ """
+
+ class RenamedModel(models.Model):
+ silly_field = models.BooleanField(default=False)
+
+ class Meta:
+ app_label = "migrations"
+
+ out = io.StringIO()
+ with self.temporary_migration_module(
+ module="migrations.test_migrations_no_default"
+ ):
+ call_command("makemigrations", "migrations", interactive=False, stdout=out)
+ self.assertIn("Delete model SillyModel", out.getvalue())
+ self.assertIn("Create model RenamedModel", out.getvalue())
+
+ def test_makemigrations_non_interactive_no_field_rename(self):
+ """
+ makemigrations adds and removes a possible field rename in
+ non-interactive mode.
+ """
+
+ class SillyModel(models.Model):
+ silly_rename = models.BooleanField(default=False)
+
+ class Meta:
+ app_label = "migrations"
+
+ out = io.StringIO()
+ with self.temporary_migration_module(
+ module="migrations.test_migrations_no_default"
+ ):
+ call_command("makemigrations", "migrations", interactive=False, stdout=out)
+ self.assertIn("Remove field silly_field from sillymodel", out.getvalue())
+ self.assertIn("Add field silly_rename to sillymodel", out.getvalue())
+
+ @mock.patch("builtins.input", return_value="Y")
+ def test_makemigrations_model_rename_interactive(self, mock_input):
+ class RenamedModel(models.Model):
+ silly_field = models.BooleanField(default=False)
+
+ class Meta:
+ app_label = "migrations"
+
+ with self.temporary_migration_module(
+ module="migrations.test_migrations_no_default",
+ ):
+ with captured_stdout() as out:
+ call_command("makemigrations", "migrations", interactive=True)
+ self.assertIn("Rename model SillyModel to RenamedModel", out.getvalue())
+
+ @mock.patch("builtins.input", return_value="Y")
+ def test_makemigrations_field_rename_interactive(self, mock_input):
+ class SillyModel(models.Model):
+ silly_rename = models.BooleanField(default=False)
+
+ class Meta:
+ app_label = "migrations"
+
+ with self.temporary_migration_module(
+ module="migrations.test_migrations_no_default",
+ ):
+ with captured_stdout() as out:
+ call_command("makemigrations", "migrations", interactive=True)
+ self.assertIn(
+ "Rename field silly_field on sillymodel to silly_rename",
+ out.getvalue(),
+ )
+
+ def test_makemigrations_handle_merge(self):
+ """
+ makemigrations properly merges the conflicting migrations with --noinput.
+ """
+ out = io.StringIO()
+ with self.temporary_migration_module(
+ module="migrations.test_migrations_conflict"
+ ) as migration_dir:
+ call_command(
+ "makemigrations",
+ "migrations",
+ name="merge",
+ merge=True,
+ interactive=False,
+ stdout=out,
+ )
+ merge_file = os.path.join(migration_dir, "0003_merge.py")
+ self.assertTrue(os.path.exists(merge_file))
+ output = out.getvalue()
+ self.assertIn("Merging migrations", output)
+ self.assertIn("Branch 0002_second", output)
+ self.assertIn("Branch 0002_conflicting_second", output)
+ self.assertIn("Created new merge migration", output)
+
+ def test_makemigration_merge_dry_run(self):
+ """
+ makemigrations respects --dry-run option when fixing migration
+ conflicts (#24427).
+ """
+ out = io.StringIO()
+ with self.temporary_migration_module(
+ module="migrations.test_migrations_conflict"
+ ) as migration_dir:
+ call_command(
+ "makemigrations",
+ "migrations",
+ name="merge",
+ dry_run=True,
+ merge=True,
+ interactive=False,
+ stdout=out,
+ )
+ merge_file = os.path.join(migration_dir, "0003_merge.py")
+ self.assertFalse(os.path.exists(merge_file))
+ output = out.getvalue()
+ self.assertIn("Merging migrations", output)
+ self.assertIn("Branch 0002_second", output)
+ self.assertIn("Branch 0002_conflicting_second", output)
+ self.assertNotIn("Created new merge migration", output)
+
+ def test_makemigration_merge_dry_run_verbosity_3(self):
+ """
+ `makemigrations --merge --dry-run` writes the merge migration file to
+ stdout with `verbosity == 3` (#24427).
+ """
+ out = io.StringIO()
+ with self.temporary_migration_module(
+ module="migrations.test_migrations_conflict"
+ ) as migration_dir:
+ call_command(
+ "makemigrations",
+ "migrations",
+ name="merge",
+ dry_run=True,
+ merge=True,
+ interactive=False,
+ stdout=out,
+ verbosity=3,
+ )
+ merge_file = os.path.join(migration_dir, "0003_merge.py")
+ self.assertFalse(os.path.exists(merge_file))
+ output = out.getvalue()
+ self.assertIn("Merging migrations", output)
+ self.assertIn("Branch 0002_second", output)
+ self.assertIn("Branch 0002_conflicting_second", output)
+ self.assertNotIn("Created new merge migration", output)
+
+ # Additional output caused by verbosity 3
+ # The complete merge migration file that would be written
+ self.assertIn("class Migration(migrations.Migration):", output)
+ self.assertIn("dependencies = [", output)
+ self.assertIn("('migrations', '0002_second')", output)
+ self.assertIn("('migrations', '0002_conflicting_second')", output)
+ self.assertIn("operations = [", output)
+ self.assertIn("]", output)
+
+ def test_makemigrations_dry_run(self):
+ """
+ `makemigrations --dry-run` should not ask for defaults.
+ """
+
+ class SillyModel(models.Model):
+ silly_field = models.BooleanField(default=False)
+ silly_date = models.DateField() # Added field without a default
+ silly_auto_now = models.DateTimeField(auto_now_add=True)
+
+ class Meta:
+ app_label = "migrations"
+
+ out = io.StringIO()
+ with self.temporary_migration_module(
+ module="migrations.test_migrations_no_default"
+ ):
+ call_command("makemigrations", "migrations", dry_run=True, stdout=out)
+ # Output the expected changes directly, without asking for defaults
+ self.assertIn("Add field silly_date to sillymodel", out.getvalue())
+
+ def test_makemigrations_dry_run_verbosity_3(self):
+ """
+ Allow `makemigrations --dry-run` to output the migrations file to
+ stdout (with verbosity == 3).
+ """
+
+ class SillyModel(models.Model):
+ silly_field = models.BooleanField(default=False)
+ silly_char = models.CharField(default="")
+
+ class Meta:
+ app_label = "migrations"
+
+ out = io.StringIO()
+ with self.temporary_migration_module(
+ module="migrations.test_migrations_no_default"
+ ):
+ call_command(
+ "makemigrations", "migrations", dry_run=True, stdout=out, verbosity=3
+ )
+
+ # Normal --dry-run output
+ self.assertIn("- Add field silly_char to sillymodel", out.getvalue())
+
+ # Additional output caused by verbosity 3
+ # The complete migrations file that would be written
+ self.assertIn("class Migration(migrations.Migration):", out.getvalue())
+ self.assertIn("dependencies = [", out.getvalue())
+ self.assertIn("('migrations', '0001_initial'),", out.getvalue())
+ self.assertIn("migrations.AddField(", out.getvalue())
+ self.assertIn("model_name='sillymodel',", out.getvalue())
+ self.assertIn("name='silly_char',", out.getvalue())
+
+ def test_makemigrations_scriptable(self):
+ """
+ With scriptable=True, log output is diverted to stderr, and only the
+ paths of generated migration files are written to stdout.
+ """
+ out = io.StringIO()
+ err = io.StringIO()
+ with self.temporary_migration_module(
+ module="migrations.migrations.test_migrations",
+ ) as migration_dir:
+ call_command(
+ "makemigrations",
+ "migrations",
+ scriptable=True,
+ stdout=out,
+ stderr=err,
+ )
+ initial_file = os.path.join(migration_dir, "0001_initial.py")
+ self.assertEqual(out.getvalue(), f"{initial_file}\n")
+ self.assertIn(" - Create model ModelWithCustomBase\n", err.getvalue())
+
+ @mock.patch("builtins.input", return_value="Y")
+ def test_makemigrations_scriptable_merge(self, mock_input):
+ out = io.StringIO()
+ err = io.StringIO()
+ with self.temporary_migration_module(
+ module="migrations.test_migrations_conflict",
+ ) as migration_dir:
+ call_command(
+ "makemigrations",
+ "migrations",
+ merge=True,
+ name="merge",
+ scriptable=True,
+ stdout=out,
+ stderr=err,
+ )
+ merge_file = os.path.join(migration_dir, "0003_merge.py")
+ self.assertEqual(out.getvalue(), f"{merge_file}\n")
+ self.assertIn(f"Created new merge migration {merge_file}", err.getvalue())
+
+ def test_makemigrations_migrations_modules_path_not_exist(self):
+ """
+ makemigrations creates migrations when specifying a custom location
+ for migration files using MIGRATION_MODULES if the custom path
+ doesn't already exist.
+ """
+
+ class SillyModel(models.Model):
+ silly_field = models.BooleanField(default=False)
+
+ class Meta:
+ app_label = "migrations"
+
+ out = io.StringIO()
+ migration_module = "migrations.test_migrations_path_doesnt_exist.foo.bar"
+ with self.temporary_migration_module(module=migration_module) as migration_dir:
+ call_command("makemigrations", "migrations", stdout=out)
+
+ # Migrations file is actually created in the expected path.
+ initial_file = os.path.join(migration_dir, "0001_initial.py")
+ self.assertTrue(os.path.exists(initial_file))
+
+ # Command output indicates the migration is created.
+ self.assertIn(" - Create model SillyModel", out.getvalue())
+
+ @override_settings(MIGRATION_MODULES={"migrations": "some.nonexistent.path"})
+ def test_makemigrations_migrations_modules_nonexistent_toplevel_package(self):
+ msg = (
+ "Could not locate an appropriate location to create migrations "
+ "package some.nonexistent.path. Make sure the toplevel package "
+ "exists and can be imported."
+ )
+ with self.assertRaisesMessage(ValueError, msg):
+ call_command("makemigrations", "migrations", empty=True, verbosity=0)
+
+ def test_makemigrations_interactive_by_default(self):
+ """
+ The user is prompted to merge by default if there are conflicts and
+ merge is True. Answer negative to differentiate it from behavior when
+ --noinput is specified.
+ """
+ # Monkeypatch interactive questioner to auto reject
+ out = io.StringIO()
+ with mock.patch("builtins.input", mock.Mock(return_value="N")):
+ with self.temporary_migration_module(
+ module="migrations.test_migrations_conflict"
+ ) as migration_dir:
+ call_command(
+ "makemigrations", "migrations", name="merge", merge=True, stdout=out
+ )
+ merge_file = os.path.join(migration_dir, "0003_merge.py")
+ # This will fail if interactive is False by default
+ self.assertFalse(os.path.exists(merge_file))
+ self.assertNotIn("Created new merge migration", out.getvalue())
+
+ @override_settings(
+ INSTALLED_APPS=[
+ "migrations",
+ "migrations.migrations_test_apps.unspecified_app_with_conflict",
+ ]
+ )
+ def test_makemigrations_unspecified_app_with_conflict_no_merge(self):
+ """
+ makemigrations does not raise a CommandError when an unspecified app
+ has conflicting migrations.
+ """
+ with self.temporary_migration_module(
+ module="migrations.test_migrations_no_changes"
+ ):
+ call_command("makemigrations", "migrations", merge=False, verbosity=0)
+
+ @override_settings(
+ INSTALLED_APPS=[
+ "migrations.migrations_test_apps.migrated_app",
+ "migrations.migrations_test_apps.unspecified_app_with_conflict",
+ ]
+ )
+ def test_makemigrations_unspecified_app_with_conflict_merge(self):
+ """
+ makemigrations does not create a merge for an unspecified app even if
+ it has conflicting migrations.
+ """
+ # Monkeypatch interactive questioner to auto accept
+ with mock.patch("builtins.input", mock.Mock(return_value="y")):
+ out = io.StringIO()
+ with self.temporary_migration_module(
+ app_label="migrated_app"
+ ) as migration_dir:
+ call_command(
+ "makemigrations",
+ "migrated_app",
+ name="merge",
+ merge=True,
+ interactive=True,
+ stdout=out,
+ )
+ merge_file = os.path.join(migration_dir, "0003_merge.py")
+ self.assertFalse(os.path.exists(merge_file))
+ self.assertIn("No conflicts detected to merge.", out.getvalue())
+
+ @override_settings(
+ INSTALLED_APPS=[
+ "migrations.migrations_test_apps.migrated_app",
+ "migrations.migrations_test_apps.conflicting_app_with_dependencies",
+ ]
+ )
+ def test_makemigrations_merge_dont_output_dependency_operations(self):
+ """
+ makemigrations --merge does not output any operations from apps that
+ don't belong to a given app.
+ """
+ # Monkeypatch interactive questioner to auto accept
+ with mock.patch("builtins.input", mock.Mock(return_value="N")):
+ out = io.StringIO()
+ with mock.patch(
+ "django.core.management.color.supports_color", lambda *args: False
+ ):
+ call_command(
+ "makemigrations",
+ "conflicting_app_with_dependencies",
+ merge=True,
+ interactive=True,
+ stdout=out,
+ )
+ self.assertEqual(
+ out.getvalue().lower(),
+ "merging conflicting_app_with_dependencies\n"
+ " branch 0002_conflicting_second\n"
+ " - create model something\n"
+ " branch 0002_second\n"
+ " - delete model tribble\n"
+ " - remove field silly_field from author\n"
+ " - add field rating to author\n"
+ " - create model book\n"
+ "\n"
+ "merging will only work if the operations printed above do not "
+ "conflict\n"
+ "with each other (working on different fields or models)\n"
+ "should these migration branches be merged? [y/n] ",
+ )
+
+ def test_makemigrations_with_custom_name(self):
+ """
+ makemigrations --name generate a custom migration name.
+ """
+ with self.temporary_migration_module() as migration_dir:
+
+ def cmd(migration_count, migration_name, *args):
+ call_command(
+ "makemigrations",
+ "migrations",
+ "--verbosity",
+ "0",
+ "--name",
+ migration_name,
+ *args,
+ )
+ migration_file = os.path.join(
+ migration_dir, "%s_%s.py" % (migration_count, migration_name)
+ )
+ # Check for existing migration file in migration folder
+ self.assertTrue(os.path.exists(migration_file))
+ with open(migration_file, encoding="utf-8") as fp:
+ content = fp.read()
+ content = content.replace(" ", "")
+ return content
+
+ # generate an initial migration
+ migration_name_0001 = "my_initial_migration"
+ content = cmd("0001", migration_name_0001)
+ self.assertIn(
+ "dependencies=[]" if HAS_BLACK else "dependencies=[\n]", content
+ )
+
+ # importlib caches os.listdir() on some platforms like macOS
+ # (#23850).
+ if hasattr(importlib, "invalidate_caches"):
+ importlib.invalidate_caches()
+
+ # generate an empty migration
+ migration_name_0002 = "my_custom_migration"
+ content = cmd("0002", migration_name_0002, "--empty")
+ if HAS_BLACK:
+ template_str = 'dependencies=[\n("migrations","0001_%s"),\n]'
+ else:
+ template_str = "dependencies=[\n('migrations','0001_%s'),\n]"
+ self.assertIn(
+ template_str % migration_name_0001,
+ content,
+ )
+ self.assertIn("operations=[]" if HAS_BLACK else "operations=[\n]", content)
+
+ def test_makemigrations_with_invalid_custom_name(self):
+ msg = "The migration name must be a valid Python identifier."
+ with self.assertRaisesMessage(CommandError, msg):
+ call_command(
+ "makemigrations", "migrations", "--name", "invalid name", "--empty"
+ )
+
+ def test_makemigrations_check(self):
+ """
+ makemigrations --check should exit with a non-zero status when
+ there are changes to an app requiring migrations.
+ """
+ with self.temporary_migration_module() as tmpdir:
+ with self.assertRaises(SystemExit):
+ call_command("makemigrations", "--check", "migrations", verbosity=0)
+ self.assertFalse(os.path.exists(tmpdir))
+
+ with self.temporary_migration_module(
+ module="migrations.test_migrations_no_changes"
+ ):
+ call_command("makemigrations", "--check", "migrations", verbosity=0)
+
+ def test_makemigrations_migration_path_output(self):
+ """
+ makemigrations should print the relative paths to the migrations unless
+ they are outside of the current tree, in which case the absolute path
+ should be shown.
+ """
+ out = io.StringIO()
+ apps.register_model("migrations", UnicodeModel)
+ with self.temporary_migration_module() as migration_dir:
+ call_command("makemigrations", "migrations", stdout=out)
+ self.assertIn(
+ os.path.join(migration_dir, "0001_initial.py"), out.getvalue()
+ )
+
+ def test_makemigrations_migration_path_output_valueerror(self):
+ """
+ makemigrations prints the absolute path if os.path.relpath() raises a
+ ValueError when it's impossible to obtain a relative path, e.g. on
+ Windows if Django is installed on a different drive than where the
+ migration files are created.
+ """
+ out = io.StringIO()
+ with self.temporary_migration_module() as migration_dir:
+ with mock.patch("os.path.relpath", side_effect=ValueError):
+ call_command("makemigrations", "migrations", stdout=out)
+ self.assertIn(os.path.join(migration_dir, "0001_initial.py"), out.getvalue())
+
+ def test_makemigrations_inconsistent_history(self):
+ """
+ makemigrations should raise InconsistentMigrationHistory exception if
+ there are some migrations applied before their dependencies.
+ """
+ recorder = MigrationRecorder(connection)
+ recorder.record_applied("migrations", "0002_second")
+ msg = (
+ "Migration migrations.0002_second is applied before its dependency "
+ "migrations.0001_initial"
+ )
+ with self.temporary_migration_module(module="migrations.test_migrations"):
+ with self.assertRaisesMessage(InconsistentMigrationHistory, msg):
+ call_command("makemigrations")
+
+ def test_makemigrations_inconsistent_history_db_failure(self):
+ msg = (
+ "Got an error checking a consistent migration history performed "
+ "for database connection 'default': could not connect to server"
+ )
+ with mock.patch(
+ "django.db.migrations.loader.MigrationLoader.check_consistent_history",
+ side_effect=OperationalError("could not connect to server"),
+ ):
+ with self.temporary_migration_module():
+ with self.assertWarns(RuntimeWarning) as cm:
+ call_command("makemigrations", verbosity=0)
+ self.assertEqual(str(cm.warning), msg)
+
+ @mock.patch("builtins.input", return_value="1")
+ @mock.patch(
+ "django.db.migrations.questioner.sys.stdin",
+ mock.MagicMock(encoding=sys.getdefaultencoding()),
+ )
+ def test_makemigrations_auto_now_add_interactive(self, *args):
+ """
+ makemigrations prompts the user when adding auto_now_add to an existing
+ model.
+ """
+
+ class Entry(models.Model):
+ title = models.CharField(max_length=255)
+ creation_date = models.DateTimeField(auto_now_add=True)
+
+ class Meta:
+ app_label = "migrations"
+
+ input_msg = (
+ "It is impossible to add the field 'creation_date' with "
+ "'auto_now_add=True' to entry without providing a default. This "
+ "is because the database needs something to populate existing "
+ "rows.\n"
+ " 1) Provide a one-off default now which will be set on all "
+ "existing rows\n"
+ " 2) Quit and manually define a default value in models.py."
+ )
+ # Monkeypatch interactive questioner to auto accept
+ prompt_stdout = io.StringIO()
+ with self.temporary_migration_module(module="migrations.test_auto_now_add"):
+ call_command(
+ "makemigrations", "migrations", interactive=True, stdout=prompt_stdout
+ )
+ prompt_output = prompt_stdout.getvalue()
+ self.assertIn(input_msg, prompt_output)
+ self.assertIn("Please enter the default value as valid Python.", prompt_output)
+ self.assertIn(
+ "Accept the default 'timezone.now' by pressing 'Enter' or provide "
+ "another value.",
+ prompt_output,
+ )
+ self.assertIn("Type 'exit' to exit this prompt", prompt_output)
+ self.assertIn("Add field creation_date to entry", prompt_output)
+
+ @mock.patch("builtins.input", return_value="2")
+ def test_makemigrations_auto_now_add_interactive_quit(self, mock_input):
+ class Author(models.Model):
+ publishing_date = models.DateField(auto_now_add=True)
+
+ class Meta:
+ app_label = "migrations"
+
+ with self.temporary_migration_module(module="migrations.test_migrations"):
+ with captured_stdout():
+ with self.assertRaises(SystemExit):
+ call_command("makemigrations", "migrations", interactive=True)
+
+ def test_makemigrations_non_interactive_auto_now_add_addition(self):
+ """
+ Non-interactive makemigrations fails when a default is missing on a
+ new field when auto_now_add=True.
+ """
+
+ class Entry(models.Model):
+ creation_date = models.DateTimeField(auto_now_add=True)
+
+ class Meta:
+ app_label = "migrations"
+
+ with self.temporary_migration_module(module="migrations.test_auto_now_add"):
+ with self.assertRaises(SystemExit), captured_stdout() as out:
+ call_command("makemigrations", "migrations", interactive=False)
+ self.assertIn(
+ "Field 'creation_date' on model 'entry' not migrated: it is "
+ "impossible to add a field with 'auto_now_add=True' without "
+ "specifying a default.",
+ out.getvalue(),
+ )
+
+ def test_makemigrations_interactive_unique_callable_default_addition(self):
+ """
+ makemigrations prompts the user when adding a unique field with
+ a callable default.
+ """
+
+ class Book(models.Model):
+ created = models.DateTimeField(unique=True, default=timezone.now)
+
+ class Meta:
+ app_label = "migrations"
+
+ version = get_docs_version()
+ input_msg = (
+ f"Callable default on unique field book.created will not generate "
+ f"unique values upon migrating.\n"
+ f"Please choose how to proceed:\n"
+ f" 1) Continue making this migration as the first step in writing "
+ f"a manual migration to generate unique values described here: "
+ f"https://docs.djangoproject.com/en/{version}/howto/"
+ f"writing-migrations/#migrations-that-add-unique-fields.\n"
+ f" 2) Quit and edit field options in models.py.\n"
+ )
+ with self.temporary_migration_module(module="migrations.test_migrations"):
+ # 2 - quit.
+ with mock.patch("builtins.input", return_value="2"):
+ with captured_stdout() as out, self.assertRaises(SystemExit):
+ call_command("makemigrations", "migrations", interactive=True)
+ out_value = out.getvalue()
+ self.assertIn(input_msg, out_value)
+ self.assertNotIn("Add field created to book", out_value)
+ # 1 - continue.
+ with mock.patch("builtins.input", return_value="1"):
+ with captured_stdout() as out:
+ call_command("makemigrations", "migrations", interactive=True)
+ out_value = out.getvalue()
+ self.assertIn(input_msg, out_value)
+ self.assertIn("Add field created to book", out_value)
+
+ def test_makemigrations_non_interactive_unique_callable_default_addition(self):
+ class Book(models.Model):
+ created = models.DateTimeField(unique=True, default=timezone.now)
+
+ class Meta:
+ app_label = "migrations"
+
+ with self.temporary_migration_module(module="migrations.test_migrations"):
+ with captured_stdout() as out:
+ call_command("makemigrations", "migrations", interactive=False)
+ out_value = out.getvalue()
+ self.assertIn("Add field created to book", out_value)
+
+ @override_settings(
+ MIGRATION_MODULES={"migrations": "migrations.test_migrations_squashed"},
+ )
+ def test_makemigrations_continues_number_sequence_after_squash(self):
+ with self.temporary_migration_module(
+ module="migrations.test_migrations_squashed"
+ ):
+ with captured_stdout() as out:
+ call_command(
+ "makemigrations",
+ "migrations",
+ interactive=False,
+ empty=True,
+ )
+ out_value = out.getvalue()
+ self.assertIn("0003_auto", out_value)
+
+ def test_makemigrations_update(self):
+ with self.temporary_migration_module(
+ module="migrations.test_migrations"
+ ) as migration_dir:
+ migration_file = os.path.join(migration_dir, "0002_second.py")
+ with open(migration_file) as fp:
+ initial_content = fp.read()
+
+ with captured_stdout() as out:
+ call_command("makemigrations", "migrations", update=True)
+ self.assertFalse(
+ any(
+ filename.startswith("0003")
+ for filename in os.listdir(migration_dir)
+ )
+ )
+ self.assertIs(os.path.exists(migration_file), False)
+ new_migration_file = os.path.join(
+ migration_dir,
+ "0002_delete_tribble_author_rating_modelwithcustombase_and_more.py",
+ )
+ with open(new_migration_file) as fp:
+ self.assertNotEqual(initial_content, fp.read())
+ self.assertIn(f"Deleted {migration_file}", out.getvalue())
+
+ def test_makemigrations_update_existing_name(self):
+ with self.temporary_migration_module(
+ module="migrations.test_auto_now_add"
+ ) as migration_dir:
+ migration_file = os.path.join(migration_dir, "0001_initial.py")
+ with open(migration_file) as fp:
+ initial_content = fp.read()
+
+ with captured_stdout() as out:
+ call_command("makemigrations", "migrations", update=True)
+ self.assertIs(os.path.exists(migration_file), False)
+ new_migration_file = os.path.join(
+ migration_dir,
+ "0001_initial_updated.py",
+ )
+ with open(new_migration_file) as fp:
+ self.assertNotEqual(initial_content, fp.read())
+ self.assertIn(f"Deleted {migration_file}", out.getvalue())
+
+ def test_makemigrations_update_custom_name(self):
+ custom_name = "delete_something"
+ with self.temporary_migration_module(
+ module="migrations.test_migrations"
+ ) as migration_dir:
+ old_migration_file = os.path.join(migration_dir, "0002_second.py")
+ with open(old_migration_file) as fp:
+ initial_content = fp.read()
+
+ with captured_stdout() as out:
+ call_command(
+ "makemigrations", "migrations", update=True, name=custom_name
+ )
+ self.assertFalse(
+ any(
+ filename.startswith("0003")
+ for filename in os.listdir(migration_dir)
+ )
+ )
+ self.assertIs(os.path.exists(old_migration_file), False)
+ new_migration_file = os.path.join(migration_dir, f"0002_{custom_name}.py")
+ self.assertIs(os.path.exists(new_migration_file), True)
+ with open(new_migration_file) as fp:
+ self.assertNotEqual(initial_content, fp.read())
+ self.assertIn(f"Deleted {old_migration_file}", out.getvalue())
+
+ def test_makemigrations_update_applied_migration(self):
+ recorder = MigrationRecorder(connection)
+ recorder.record_applied("migrations", "0001_initial")
+ recorder.record_applied("migrations", "0002_second")
+ with self.temporary_migration_module(module="migrations.test_migrations"):
+ msg = "Cannot update applied migration 'migrations.0002_second'."
+ with self.assertRaisesMessage(CommandError, msg):
+ call_command("makemigrations", "migrations", update=True)
+
+ def test_makemigrations_update_no_migration(self):
+ with self.temporary_migration_module(module="migrations.test_migrations_empty"):
+ msg = "App migrations has no migration, cannot update last migration."
+ with self.assertRaisesMessage(CommandError, msg):
+ call_command("makemigrations", "migrations", update=True)
+
+ def test_makemigrations_update_squash_migration(self):
+ with self.temporary_migration_module(
+ module="migrations.test_migrations_squashed"
+ ):
+ msg = "Cannot update squash migration 'migrations.0001_squashed_0002'."
+ with self.assertRaisesMessage(CommandError, msg):
+ call_command("makemigrations", "migrations", update=True)
+
+ def test_makemigrations_update_manual_porting(self):
+ with self.temporary_migration_module(
+ module="migrations.test_migrations_plan"
+ ) as migration_dir:
+ with captured_stdout() as out:
+ call_command("makemigrations", "migrations", update=True)
+ # Previous migration exists.
+ previous_migration_file = os.path.join(migration_dir, "0005_fifth.py")
+ self.assertIs(os.path.exists(previous_migration_file), True)
+ # New updated migration exists.
+ files = [f for f in os.listdir(migration_dir) if f.startswith("0005_auto")]
+ updated_migration_file = os.path.join(migration_dir, files[0])
+ self.assertIs(os.path.exists(updated_migration_file), True)
+ self.assertIn(
+ f"Updated migration {updated_migration_file} requires manual porting.\n"
+ f"Previous migration {previous_migration_file} was kept and must be "
+ f"deleted after porting functions manually.",
+ out.getvalue(),
+ )
+
+ @override_settings(
+ INSTALLED_APPS=[
+ "migrations.migrations_test_apps.alter_fk.author_app",
+ "migrations.migrations_test_apps.alter_fk.book_app",
+ ]
+ )
+ def test_makemigrations_update_dependency_migration(self):
+ with self.temporary_migration_module(app_label="book_app"):
+ msg = (
+ "Cannot update migration 'book_app.0001_initial' that migrations "
+ "'author_app.0002_alter_id' depend on."
+ )
+ with self.assertRaisesMessage(CommandError, msg):
+ call_command("makemigrations", "book_app", update=True)
+
+
+class SquashMigrationsTests(MigrationTestBase):
+ """
+ Tests running the squashmigrations command.
+ """
+
+ def test_squashmigrations_squashes(self):
+ """
+ squashmigrations squashes migrations.
+ """
+ out = io.StringIO()
+ with self.temporary_migration_module(
+ module="migrations.test_migrations"
+ ) as migration_dir:
+ call_command(
+ "squashmigrations",
+ "migrations",
+ "0002",
+ interactive=False,
+ stdout=out,
+ no_color=True,
+ )
+
+ squashed_migration_file = os.path.join(
+ migration_dir, "0001_squashed_0002_second.py"
+ )
+ self.assertTrue(os.path.exists(squashed_migration_file))
+ self.assertEqual(
+ out.getvalue(),
+ "Will squash the following migrations:\n"
+ " - 0001_initial\n"
+ " - 0002_second\n"
+ "Optimizing...\n"
+ " Optimized from 8 operations to 2 operations.\n"
+ "Created new squashed migration %s\n"
+ " You should commit this migration but leave the old ones in place;\n"
+ " the new migration will be used for new installs. Once you are sure\n"
+ " all instances of the codebase have applied the migrations you "
+ "squashed,\n"
+ " you can delete them.\n" % squashed_migration_file,
+ )
+
+ def test_squashmigrations_initial_attribute(self):
+ with self.temporary_migration_module(
+ module="migrations.test_migrations"
+ ) as migration_dir:
+ call_command(
+ "squashmigrations", "migrations", "0002", interactive=False, verbosity=0
+ )
+
+ squashed_migration_file = os.path.join(
+ migration_dir, "0001_squashed_0002_second.py"
+ )
+ with open(squashed_migration_file, encoding="utf-8") as fp:
+ content = fp.read()
+ self.assertIn("initial = True", content)
+
+ def test_squashmigrations_optimizes(self):
+ """
+ squashmigrations optimizes operations.
+ """
+ out = io.StringIO()
+ with self.temporary_migration_module(module="migrations.test_migrations"):
+ call_command(
+ "squashmigrations",
+ "migrations",
+ "0002",
+ interactive=False,
+ verbosity=1,
+ stdout=out,
+ )
+ self.assertIn("Optimized from 8 operations to 2 operations.", out.getvalue())
+
+ def test_ticket_23799_squashmigrations_no_optimize(self):
+ """
+ squashmigrations --no-optimize doesn't optimize operations.
+ """
+ out = io.StringIO()
+ with self.temporary_migration_module(module="migrations.test_migrations"):
+ call_command(
+ "squashmigrations",
+ "migrations",
+ "0002",
+ interactive=False,
+ verbosity=1,
+ no_optimize=True,
+ stdout=out,
+ )
+ self.assertIn("Skipping optimization", out.getvalue())
+
+ def test_squashmigrations_valid_start(self):
+ """
+ squashmigrations accepts a starting migration.
+ """
+ out = io.StringIO()
+ with self.temporary_migration_module(
+ module="migrations.test_migrations_no_changes"
+ ) as migration_dir:
+ call_command(
+ "squashmigrations",
+ "migrations",
+ "0002",
+ "0003",
+ interactive=False,
+ verbosity=1,
+ stdout=out,
+ )
+
+ squashed_migration_file = os.path.join(
+ migration_dir, "0002_second_squashed_0003_third.py"
+ )
+ with open(squashed_migration_file, encoding="utf-8") as fp:
+ content = fp.read()
+ if HAS_BLACK:
+ test_str = ' ("migrations", "0001_initial")'
+ else:
+ test_str = " ('migrations', '0001_initial')"
+ self.assertIn(test_str, content)
+ self.assertNotIn("initial = True", content)
+ out = out.getvalue()
+ self.assertNotIn(" - 0001_initial", out)
+ self.assertIn(" - 0002_second", out)
+ self.assertIn(" - 0003_third", out)
+
+ def test_squashmigrations_invalid_start(self):
+ """
+ squashmigrations doesn't accept a starting migration after the ending migration.
+ """
+ with self.temporary_migration_module(
+ module="migrations.test_migrations_no_changes"
+ ):
+ msg = (
+ "The migration 'migrations.0003_third' cannot be found. Maybe "
+ "it comes after the migration 'migrations.0002_second'"
+ )
+ with self.assertRaisesMessage(CommandError, msg):
+ call_command(
+ "squashmigrations",
+ "migrations",
+ "0003",
+ "0002",
+ interactive=False,
+ verbosity=0,
+ )
+
+ def test_squashed_name_with_start_migration_name(self):
+ """--squashed-name specifies the new migration's name."""
+ squashed_name = "squashed_name"
+ with self.temporary_migration_module(
+ module="migrations.test_migrations"
+ ) as migration_dir:
+ call_command(
+ "squashmigrations",
+ "migrations",
+ "0001",
+ "0002",
+ squashed_name=squashed_name,
+ interactive=False,
+ verbosity=0,
+ )
+ squashed_migration_file = os.path.join(
+ migration_dir, "0001_%s.py" % squashed_name
+ )
+ self.assertTrue(os.path.exists(squashed_migration_file))
+
+ def test_squashed_name_without_start_migration_name(self):
+ """--squashed-name also works if a start migration is omitted."""
+ squashed_name = "squashed_name"
+ with self.temporary_migration_module(
+ module="migrations.test_migrations"
+ ) as migration_dir:
+ call_command(
+ "squashmigrations",
+ "migrations",
+ "0001",
+ squashed_name=squashed_name,
+ interactive=False,
+ verbosity=0,
+ )
+ squashed_migration_file = os.path.join(
+ migration_dir, "0001_%s.py" % squashed_name
+ )
+ self.assertTrue(os.path.exists(squashed_migration_file))
+
+ def test_squashed_name_exists(self):
+ msg = "Migration 0001_initial already exists. Use a different name."
+ with self.temporary_migration_module(module="migrations.test_migrations"):
+ with self.assertRaisesMessage(CommandError, msg):
+ call_command(
+ "squashmigrations",
+ "migrations",
+ "0001",
+ "0002",
+ squashed_name="initial",
+ interactive=False,
+ verbosity=0,
+ )
+
+ def test_squashmigrations_manual_porting(self):
+ out = io.StringIO()
+ with self.temporary_migration_module(
+ module="migrations.test_migrations_manual_porting",
+ ) as migration_dir:
+ call_command(
+ "squashmigrations",
+ "migrations",
+ "0002",
+ interactive=False,
+ stdout=out,
+ no_color=True,
+ )
+ squashed_migration_file = os.path.join(
+ migration_dir,
+ "0001_squashed_0002_second.py",
+ )
+ self.assertTrue(os.path.exists(squashed_migration_file))
+ black_warning = ""
+ if HAS_BLACK:
+ black_warning = (
+ "Squashed migration couldn't be formatted using the "
+ '"black" command. You can call it manually.\n'
+ )
+ self.assertEqual(
+ out.getvalue(),
+ f"Will squash the following migrations:\n"
+ f" - 0001_initial\n"
+ f" - 0002_second\n"
+ f"Optimizing...\n"
+ f" No optimizations possible.\n"
+ f"Created new squashed migration {squashed_migration_file}\n"
+ f" You should commit this migration but leave the old ones in place;\n"
+ f" the new migration will be used for new installs. Once you are sure\n"
+ f" all instances of the codebase have applied the migrations you "
+ f"squashed,\n"
+ f" you can delete them.\n"
+ f"Manual porting required\n"
+ f" Your migrations contained functions that must be manually copied "
+ f"over,\n"
+ f" as we could not safely copy their implementation.\n"
+ f" See the comment at the top of the squashed migration for details.\n"
+ + black_warning,
+ )
+
+
+class AppLabelErrorTests(TestCase):
+ """
+ This class inherits TestCase because MigrationTestBase uses
+ `available_apps = ['migrations']` which means that it's the only installed
+ app. 'django.contrib.auth' must be in INSTALLED_APPS for some of these
+ tests.
+ """
+
+ nonexistent_app_error = "No installed app with label 'nonexistent_app'."
+ did_you_mean_auth_error = (
+ "No installed app with label 'django.contrib.auth'. Did you mean 'auth'?"
+ )
+
+ def test_makemigrations_nonexistent_app_label(self):
+ err = io.StringIO()
+ with self.assertRaises(SystemExit):
+ call_command("makemigrations", "nonexistent_app", stderr=err)
+ self.assertIn(self.nonexistent_app_error, err.getvalue())
+
+ def test_makemigrations_app_name_specified_as_label(self):
+ err = io.StringIO()
+ with self.assertRaises(SystemExit):
+ call_command("makemigrations", "django.contrib.auth", stderr=err)
+ self.assertIn(self.did_you_mean_auth_error, err.getvalue())
+
+ def test_migrate_nonexistent_app_label(self):
+ with self.assertRaisesMessage(CommandError, self.nonexistent_app_error):
+ call_command("migrate", "nonexistent_app")
+
+ def test_migrate_app_name_specified_as_label(self):
+ with self.assertRaisesMessage(CommandError, self.did_you_mean_auth_error):
+ call_command("migrate", "django.contrib.auth")
+
+ def test_showmigrations_nonexistent_app_label(self):
+ err = io.StringIO()
+ with self.assertRaises(SystemExit):
+ call_command("showmigrations", "nonexistent_app", stderr=err)
+ self.assertIn(self.nonexistent_app_error, err.getvalue())
+
+ def test_showmigrations_app_name_specified_as_label(self):
+ err = io.StringIO()
+ with self.assertRaises(SystemExit):
+ call_command("showmigrations", "django.contrib.auth", stderr=err)
+ self.assertIn(self.did_you_mean_auth_error, err.getvalue())
+
+ def test_sqlmigrate_nonexistent_app_label(self):
+ with self.assertRaisesMessage(CommandError, self.nonexistent_app_error):
+ call_command("sqlmigrate", "nonexistent_app", "0002")
+
+ def test_sqlmigrate_app_name_specified_as_label(self):
+ with self.assertRaisesMessage(CommandError, self.did_you_mean_auth_error):
+ call_command("sqlmigrate", "django.contrib.auth", "0002")
+
+ def test_squashmigrations_nonexistent_app_label(self):
+ with self.assertRaisesMessage(CommandError, self.nonexistent_app_error):
+ call_command("squashmigrations", "nonexistent_app", "0002")
+
+ def test_squashmigrations_app_name_specified_as_label(self):
+ with self.assertRaisesMessage(CommandError, self.did_you_mean_auth_error):
+ call_command("squashmigrations", "django.contrib.auth", "0002")
+
+ def test_optimizemigration_nonexistent_app_label(self):
+ with self.assertRaisesMessage(CommandError, self.nonexistent_app_error):
+ call_command("optimizemigration", "nonexistent_app", "0002")
+
+ def test_optimizemigration_app_name_specified_as_label(self):
+ with self.assertRaisesMessage(CommandError, self.did_you_mean_auth_error):
+ call_command("optimizemigration", "django.contrib.auth", "0002")
+
+
+class OptimizeMigrationTests(MigrationTestBase):
+ def test_no_optimization_possible(self):
+ out = io.StringIO()
+ with self.temporary_migration_module(
+ module="migrations.test_migrations"
+ ) as migration_dir:
+ call_command(
+ "optimizemigration", "migrations", "0002", stdout=out, no_color=True
+ )
+ migration_file = os.path.join(migration_dir, "0002_second.py")
+ self.assertTrue(os.path.exists(migration_file))
+ call_command(
+ "optimizemigration",
+ "migrations",
+ "0002",
+ stdout=out,
+ no_color=True,
+ verbosity=0,
+ )
+ self.assertEqual(out.getvalue(), "No optimizations possible.\n")
+
+ def test_optimization(self):
+ out = io.StringIO()
+ with self.temporary_migration_module(
+ module="migrations.test_migrations"
+ ) as migration_dir:
+ call_command(
+ "optimizemigration", "migrations", "0001", stdout=out, no_color=True
+ )
+ initial_migration_file = os.path.join(migration_dir, "0001_initial.py")
+ self.assertTrue(os.path.exists(initial_migration_file))
+ with open(initial_migration_file) as fp:
+ content = fp.read()
+ self.assertIn(
+ '("bool", models.BooleanField'
+ if HAS_BLACK
+ else "('bool', models.BooleanField",
+ content,
+ )
+ self.assertEqual(
+ out.getvalue(),
+ f"Optimizing from 4 operations to 2 operations.\n"
+ f"Optimized migration {initial_migration_file}\n",
+ )
+
+ def test_optimization_no_verbosity(self):
+ out = io.StringIO()
+ with self.temporary_migration_module(
+ module="migrations.test_migrations"
+ ) as migration_dir:
+ call_command(
+ "optimizemigration",
+ "migrations",
+ "0001",
+ stdout=out,
+ no_color=True,
+ verbosity=0,
+ )
+ initial_migration_file = os.path.join(migration_dir, "0001_initial.py")
+ self.assertTrue(os.path.exists(initial_migration_file))
+ with open(initial_migration_file) as fp:
+ content = fp.read()
+ self.assertIn(
+ '("bool", models.BooleanField'
+ if HAS_BLACK
+ else "('bool', models.BooleanField",
+ content,
+ )
+ self.assertEqual(out.getvalue(), "")
+
+ def test_creates_replace_migration_manual_porting(self):
+ out = io.StringIO()
+ with self.temporary_migration_module(
+ module="migrations.test_migrations_manual_porting"
+ ) as migration_dir:
+ call_command(
+ "optimizemigration", "migrations", "0003", stdout=out, no_color=True
+ )
+ optimized_migration_file = os.path.join(
+ migration_dir, "0003_third_optimized.py"
+ )
+ self.assertTrue(os.path.exists(optimized_migration_file))
+ with open(optimized_migration_file) as fp:
+ content = fp.read()
+ self.assertIn("replaces = [", content)
+ black_warning = ""
+ if HAS_BLACK:
+ black_warning = (
+ "Optimized migration couldn't be formatted using the "
+ '"black" command. You can call it manually.\n'
+ )
+ self.assertEqual(
+ out.getvalue(),
+ "Optimizing from 3 operations to 2 operations.\n"
+ "Manual porting required\n"
+ " Your migrations contained functions that must be manually copied over,\n"
+ " as we could not safely copy their implementation.\n"
+ " See the comment at the top of the optimized migration for details.\n"
+ + black_warning
+ + f"Optimized migration {optimized_migration_file}\n",
+ )
+
+ def test_fails_squash_migration_manual_porting(self):
+ out = io.StringIO()
+ with self.temporary_migration_module(
+ module="migrations.test_migrations_manual_porting"
+ ) as migration_dir:
+ version = get_docs_version()
+ msg = (
+ f"Migration will require manual porting but is already a squashed "
+ f"migration.\nTransition to a normal migration first: "
+ f"https://docs.djangoproject.com/en/{version}/topics/migrations/"
+ f"#squashing-migrations"
+ )
+ with self.assertRaisesMessage(CommandError, msg):
+ call_command("optimizemigration", "migrations", "0004", stdout=out)
+ optimized_migration_file = os.path.join(
+ migration_dir, "0004_fourth_optimized.py"
+ )
+ self.assertFalse(os.path.exists(optimized_migration_file))
+ self.assertEqual(
+ out.getvalue(), "Optimizing from 3 operations to 2 operations.\n"
+ )
+
+ @override_settings(MIGRATION_MODULES={"migrations": "migrations.test_migrations"})
+ def test_optimizemigration_check(self):
+ with self.assertRaises(SystemExit):
+ call_command(
+ "optimizemigration", "--check", "migrations", "0001", verbosity=0
+ )
+
+ call_command("optimizemigration", "--check", "migrations", "0002", verbosity=0)
+
+ @override_settings(
+ INSTALLED_APPS=["migrations.migrations_test_apps.unmigrated_app_simple"],
+ )
+ def test_app_without_migrations(self):
+ msg = "App 'unmigrated_app_simple' does not have migrations."
+ with self.assertRaisesMessage(CommandError, msg):
+ call_command("optimizemigration", "unmigrated_app_simple", "0001")
+
+ @override_settings(
+ MIGRATION_MODULES={"migrations": "migrations.test_migrations_clashing_prefix"},
+ )
+ def test_ambigious_prefix(self):
+ msg = (
+ "More than one migration matches 'a' in app 'migrations'. Please "
+ "be more specific."
+ )
+ with self.assertRaisesMessage(CommandError, msg):
+ call_command("optimizemigration", "migrations", "a")
+
+ @override_settings(MIGRATION_MODULES={"migrations": "migrations.test_migrations"})
+ def test_unknown_prefix(self):
+ msg = "Cannot find a migration matching 'nonexistent' from app 'migrations'."
+ with self.assertRaisesMessage(CommandError, msg):
+ call_command("optimizemigration", "migrations", "nonexistent")
diff --git a/testbed/django__django/tests/migrations/test_deprecated_fields.py b/testbed/django__django/tests/migrations/test_deprecated_fields.py
new file mode 100644
index 0000000000000000000000000000000000000000..63975514f65602579ce80b14cb4c25bedbe90e11
--- /dev/null
+++ b/testbed/django__django/tests/migrations/test_deprecated_fields.py
@@ -0,0 +1,25 @@
+from django.core.management import call_command
+from django.test import override_settings
+
+from .test_base import MigrationTestBase
+
+
+class Tests(MigrationTestBase):
+ """
+ Deprecated model fields should still be usable in historic migrations.
+ """
+
+ @override_settings(
+ MIGRATION_MODULES={"migrations": "migrations.deprecated_field_migrations"}
+ )
+ def test_migrate(self):
+ # Make sure no tables are created
+ self.assertTableNotExists("migrations_ipaddressfield")
+ # Run migration
+ call_command("migrate", verbosity=0)
+ # Make sure the right tables exist
+ self.assertTableExists("migrations_ipaddressfield")
+ # Unmigrate everything
+ call_command("migrate", "migrations", "zero", verbosity=0)
+ # Make sure it's all gone
+ self.assertTableNotExists("migrations_ipaddressfield")
diff --git a/testbed/django__django/tests/migrations/test_exceptions.py b/testbed/django__django/tests/migrations/test_exceptions.py
new file mode 100644
index 0000000000000000000000000000000000000000..64d2109d5af397dd212e1f4eb380860324695354
--- /dev/null
+++ b/testbed/django__django/tests/migrations/test_exceptions.py
@@ -0,0 +1,11 @@
+from django.db.migrations.exceptions import NodeNotFoundError
+from django.test import SimpleTestCase
+
+
+class ExceptionTests(SimpleTestCase):
+ def test_node_not_found_error_repr(self):
+ node = ("some_app_label", "some_migration_label")
+ error_repr = repr(NodeNotFoundError("some message", node))
+ self.assertEqual(
+ error_repr, "NodeNotFoundError(('some_app_label', 'some_migration_label'))"
+ )
diff --git a/testbed/django__django/tests/migrations/test_executor.py b/testbed/django__django/tests/migrations/test_executor.py
new file mode 100644
index 0000000000000000000000000000000000000000..6232b44b986cfad0c0ac2b59942a59b1291bc590
--- /dev/null
+++ b/testbed/django__django/tests/migrations/test_executor.py
@@ -0,0 +1,998 @@
+from unittest import mock
+
+from django.apps.registry import apps as global_apps
+from django.db import DatabaseError, connection, migrations, models
+from django.db.migrations.exceptions import InvalidMigrationPlan
+from django.db.migrations.executor import MigrationExecutor
+from django.db.migrations.graph import MigrationGraph
+from django.db.migrations.recorder import MigrationRecorder
+from django.db.migrations.state import ProjectState
+from django.test import (
+ SimpleTestCase,
+ modify_settings,
+ override_settings,
+ skipUnlessDBFeature,
+)
+from django.test.utils import isolate_lru_cache
+
+from .test_base import MigrationTestBase
+
+
+@modify_settings(INSTALLED_APPS={"append": "migrations2"})
+class ExecutorTests(MigrationTestBase):
+ """
+ Tests the migration executor (full end-to-end running).
+
+ Bear in mind that if these are failing you should fix the other
+ test failures first, as they may be propagating into here.
+ """
+
+ available_apps = [
+ "migrations",
+ "migrations2",
+ "django.contrib.auth",
+ "django.contrib.contenttypes",
+ ]
+
+ @override_settings(MIGRATION_MODULES={"migrations": "migrations.test_migrations"})
+ def test_run(self):
+ """
+ Tests running a simple set of migrations.
+ """
+ executor = MigrationExecutor(connection)
+ # Let's look at the plan first and make sure it's up to scratch
+ plan = executor.migration_plan([("migrations", "0002_second")])
+ self.assertEqual(
+ plan,
+ [
+ (executor.loader.graph.nodes["migrations", "0001_initial"], False),
+ (executor.loader.graph.nodes["migrations", "0002_second"], False),
+ ],
+ )
+ # Were the tables there before?
+ self.assertTableNotExists("migrations_author")
+ self.assertTableNotExists("migrations_book")
+ # Alright, let's try running it
+ executor.migrate([("migrations", "0002_second")])
+ # Are the tables there now?
+ self.assertTableExists("migrations_author")
+ self.assertTableExists("migrations_book")
+ # Rebuild the graph to reflect the new DB state
+ executor.loader.build_graph()
+ # Alright, let's undo what we did
+ plan = executor.migration_plan([("migrations", None)])
+ self.assertEqual(
+ plan,
+ [
+ (executor.loader.graph.nodes["migrations", "0002_second"], True),
+ (executor.loader.graph.nodes["migrations", "0001_initial"], True),
+ ],
+ )
+ executor.migrate([("migrations", None)])
+ # Are the tables gone?
+ self.assertTableNotExists("migrations_author")
+ self.assertTableNotExists("migrations_book")
+
+ @override_settings(
+ MIGRATION_MODULES={"migrations": "migrations.test_migrations_squashed"}
+ )
+ def test_run_with_squashed(self):
+ """
+ Tests running a squashed migration from zero (should ignore what it replaces)
+ """
+ executor = MigrationExecutor(connection)
+ # Check our leaf node is the squashed one
+ leaves = [
+ key for key in executor.loader.graph.leaf_nodes() if key[0] == "migrations"
+ ]
+ self.assertEqual(leaves, [("migrations", "0001_squashed_0002")])
+ # Check the plan
+ plan = executor.migration_plan([("migrations", "0001_squashed_0002")])
+ self.assertEqual(
+ plan,
+ [
+ (
+ executor.loader.graph.nodes["migrations", "0001_squashed_0002"],
+ False,
+ ),
+ ],
+ )
+ # Were the tables there before?
+ self.assertTableNotExists("migrations_author")
+ self.assertTableNotExists("migrations_book")
+ # Alright, let's try running it
+ executor.migrate([("migrations", "0001_squashed_0002")])
+ # Are the tables there now?
+ self.assertTableExists("migrations_author")
+ self.assertTableExists("migrations_book")
+ # Rebuild the graph to reflect the new DB state
+ executor.loader.build_graph()
+ # Alright, let's undo what we did. Should also just use squashed.
+ plan = executor.migration_plan([("migrations", None)])
+ self.assertEqual(
+ plan,
+ [
+ (executor.loader.graph.nodes["migrations", "0001_squashed_0002"], True),
+ ],
+ )
+ executor.migrate([("migrations", None)])
+ # Are the tables gone?
+ self.assertTableNotExists("migrations_author")
+ self.assertTableNotExists("migrations_book")
+
+ @override_settings(
+ MIGRATION_MODULES={"migrations": "migrations.test_migrations_squashed"},
+ )
+ def test_migrate_backward_to_squashed_migration(self):
+ executor = MigrationExecutor(connection)
+ try:
+ self.assertTableNotExists("migrations_author")
+ self.assertTableNotExists("migrations_book")
+ executor.migrate([("migrations", "0001_squashed_0002")])
+ self.assertTableExists("migrations_author")
+ self.assertTableExists("migrations_book")
+ executor.loader.build_graph()
+ # Migrate backward to a squashed migration.
+ executor.migrate([("migrations", "0001_initial")])
+ self.assertTableExists("migrations_author")
+ self.assertTableNotExists("migrations_book")
+ finally:
+ # Unmigrate everything.
+ executor = MigrationExecutor(connection)
+ executor.migrate([("migrations", None)])
+ self.assertTableNotExists("migrations_author")
+ self.assertTableNotExists("migrations_book")
+
+ @override_settings(
+ MIGRATION_MODULES={"migrations": "migrations.test_migrations_non_atomic"}
+ )
+ def test_non_atomic_migration(self):
+ """
+ Applying a non-atomic migration works as expected.
+ """
+ executor = MigrationExecutor(connection)
+ with self.assertRaisesMessage(RuntimeError, "Abort migration"):
+ executor.migrate([("migrations", "0001_initial")])
+ self.assertTableExists("migrations_publisher")
+ migrations_apps = executor.loader.project_state(
+ ("migrations", "0001_initial")
+ ).apps
+ Publisher = migrations_apps.get_model("migrations", "Publisher")
+ self.assertTrue(Publisher.objects.exists())
+ self.assertTableNotExists("migrations_book")
+
+ @override_settings(
+ MIGRATION_MODULES={"migrations": "migrations.test_migrations_atomic_operation"}
+ )
+ def test_atomic_operation_in_non_atomic_migration(self):
+ """
+ An atomic operation is properly rolled back inside a non-atomic
+ migration.
+ """
+ executor = MigrationExecutor(connection)
+ with self.assertRaisesMessage(RuntimeError, "Abort migration"):
+ executor.migrate([("migrations", "0001_initial")])
+ migrations_apps = executor.loader.project_state(
+ ("migrations", "0001_initial")
+ ).apps
+ Editor = migrations_apps.get_model("migrations", "Editor")
+ self.assertFalse(Editor.objects.exists())
+ # Record previous migration as successful.
+ executor.migrate([("migrations", "0001_initial")], fake=True)
+ # Rebuild the graph to reflect the new DB state.
+ executor.loader.build_graph()
+ # Migrating backwards is also atomic.
+ with self.assertRaisesMessage(RuntimeError, "Abort migration"):
+ executor.migrate([("migrations", None)])
+ self.assertFalse(Editor.objects.exists())
+
+ @override_settings(
+ MIGRATION_MODULES={
+ "migrations": "migrations.test_migrations",
+ "migrations2": "migrations2.test_migrations_2",
+ }
+ )
+ def test_empty_plan(self):
+ """
+ Re-planning a full migration of a fully-migrated set doesn't
+ perform spurious unmigrations and remigrations.
+
+ There was previously a bug where the executor just always performed the
+ backwards plan for applied migrations - which even for the most recent
+ migration in an app, might include other, dependent apps, and these
+ were being unmigrated.
+ """
+ # Make the initial plan, check it
+ executor = MigrationExecutor(connection)
+ plan = executor.migration_plan(
+ [
+ ("migrations", "0002_second"),
+ ("migrations2", "0001_initial"),
+ ]
+ )
+ self.assertEqual(
+ plan,
+ [
+ (executor.loader.graph.nodes["migrations", "0001_initial"], False),
+ (executor.loader.graph.nodes["migrations", "0002_second"], False),
+ (executor.loader.graph.nodes["migrations2", "0001_initial"], False),
+ ],
+ )
+ # Fake-apply all migrations
+ executor.migrate(
+ [("migrations", "0002_second"), ("migrations2", "0001_initial")], fake=True
+ )
+ # Rebuild the graph to reflect the new DB state
+ executor.loader.build_graph()
+ # Now plan a second time and make sure it's empty
+ plan = executor.migration_plan(
+ [
+ ("migrations", "0002_second"),
+ ("migrations2", "0001_initial"),
+ ]
+ )
+ self.assertEqual(plan, [])
+ # The resulting state should include applied migrations.
+ state = executor.migrate(
+ [
+ ("migrations", "0002_second"),
+ ("migrations2", "0001_initial"),
+ ]
+ )
+ self.assertIn(("migrations", "book"), state.models)
+ self.assertIn(("migrations", "author"), state.models)
+ self.assertIn(("migrations2", "otherauthor"), state.models)
+ # Erase all the fake records
+ executor.recorder.record_unapplied("migrations2", "0001_initial")
+ executor.recorder.record_unapplied("migrations", "0002_second")
+ executor.recorder.record_unapplied("migrations", "0001_initial")
+
+ @override_settings(
+ MIGRATION_MODULES={
+ "migrations": "migrations.test_migrations",
+ "migrations2": "migrations2.test_migrations_2_no_deps",
+ }
+ )
+ def test_mixed_plan_not_supported(self):
+ """
+ Although the MigrationExecutor interfaces allows for mixed migration
+ plans (combined forwards and backwards migrations) this is not
+ supported.
+ """
+ # Prepare for mixed plan
+ executor = MigrationExecutor(connection)
+ plan = executor.migration_plan([("migrations", "0002_second")])
+ self.assertEqual(
+ plan,
+ [
+ (executor.loader.graph.nodes["migrations", "0001_initial"], False),
+ (executor.loader.graph.nodes["migrations", "0002_second"], False),
+ ],
+ )
+ executor.migrate(None, plan)
+ # Rebuild the graph to reflect the new DB state
+ executor.loader.build_graph()
+ self.assertIn(
+ ("migrations", "0001_initial"), executor.loader.applied_migrations
+ )
+ self.assertIn(("migrations", "0002_second"), executor.loader.applied_migrations)
+ self.assertNotIn(
+ ("migrations2", "0001_initial"), executor.loader.applied_migrations
+ )
+
+ # Generate mixed plan
+ plan = executor.migration_plan(
+ [
+ ("migrations", None),
+ ("migrations2", "0001_initial"),
+ ]
+ )
+ msg = (
+ "Migration plans with both forwards and backwards migrations are "
+ "not supported. Please split your migration process into separate "
+ "plans of only forwards OR backwards migrations."
+ )
+ with self.assertRaisesMessage(InvalidMigrationPlan, msg) as cm:
+ executor.migrate(None, plan)
+ self.assertEqual(
+ cm.exception.args[1],
+ [
+ (executor.loader.graph.nodes["migrations", "0002_second"], True),
+ (executor.loader.graph.nodes["migrations", "0001_initial"], True),
+ (executor.loader.graph.nodes["migrations2", "0001_initial"], False),
+ ],
+ )
+ # Rebuild the graph to reflect the new DB state
+ executor.loader.build_graph()
+ executor.migrate(
+ [
+ ("migrations", None),
+ ("migrations2", None),
+ ]
+ )
+ # Are the tables gone?
+ self.assertTableNotExists("migrations_author")
+ self.assertTableNotExists("migrations_book")
+ self.assertTableNotExists("migrations2_otherauthor")
+
+ @override_settings(MIGRATION_MODULES={"migrations": "migrations.test_migrations"})
+ def test_soft_apply(self):
+ """
+ Tests detection of initial migrations already having been applied.
+ """
+ state = {"faked": None}
+
+ def fake_storer(phase, migration=None, fake=None):
+ state["faked"] = fake
+
+ executor = MigrationExecutor(connection, progress_callback=fake_storer)
+ # Were the tables there before?
+ self.assertTableNotExists("migrations_author")
+ self.assertTableNotExists("migrations_tribble")
+ # Run it normally
+ self.assertEqual(
+ executor.migration_plan([("migrations", "0001_initial")]),
+ [
+ (executor.loader.graph.nodes["migrations", "0001_initial"], False),
+ ],
+ )
+ executor.migrate([("migrations", "0001_initial")])
+ # Are the tables there now?
+ self.assertTableExists("migrations_author")
+ self.assertTableExists("migrations_tribble")
+ # We shouldn't have faked that one
+ self.assertIs(state["faked"], False)
+ # Rebuild the graph to reflect the new DB state
+ executor.loader.build_graph()
+ # Fake-reverse that
+ executor.migrate([("migrations", None)], fake=True)
+ # Are the tables still there?
+ self.assertTableExists("migrations_author")
+ self.assertTableExists("migrations_tribble")
+ # Make sure that was faked
+ self.assertIs(state["faked"], True)
+ # Finally, migrate forwards; this should fake-apply our initial migration
+ executor.loader.build_graph()
+ self.assertEqual(
+ executor.migration_plan([("migrations", "0001_initial")]),
+ [
+ (executor.loader.graph.nodes["migrations", "0001_initial"], False),
+ ],
+ )
+ # Applying the migration should raise a database level error
+ # because we haven't given the --fake-initial option
+ with self.assertRaises(DatabaseError):
+ executor.migrate([("migrations", "0001_initial")])
+ # Reset the faked state
+ state = {"faked": None}
+ # Allow faking of initial CreateModel operations
+ executor.migrate([("migrations", "0001_initial")], fake_initial=True)
+ self.assertIs(state["faked"], True)
+ # And migrate back to clean up the database
+ executor.loader.build_graph()
+ executor.migrate([("migrations", None)])
+ self.assertTableNotExists("migrations_author")
+ self.assertTableNotExists("migrations_tribble")
+
+ @override_settings(
+ MIGRATION_MODULES={
+ "migrations": "migrations.test_migrations_custom_user",
+ "django.contrib.auth": "django.contrib.auth.migrations",
+ },
+ AUTH_USER_MODEL="migrations.Author",
+ )
+ def test_custom_user(self):
+ """
+ Regression test for #22325 - references to a custom user model defined in the
+ same app are not resolved correctly.
+ """
+ with isolate_lru_cache(global_apps.get_swappable_settings_name):
+ executor = MigrationExecutor(connection)
+ self.assertTableNotExists("migrations_author")
+ self.assertTableNotExists("migrations_tribble")
+ # Migrate forwards
+ executor.migrate([("migrations", "0001_initial")])
+ self.assertTableExists("migrations_author")
+ self.assertTableExists("migrations_tribble")
+ # The soft-application detection works.
+ # Change table_names to not return auth_user during this as it
+ # wouldn't be there in a normal run, and ensure migrations.Author
+ # exists in the global app registry temporarily.
+ old_table_names = connection.introspection.table_names
+ connection.introspection.table_names = lambda c: [
+ x for x in old_table_names(c) if x != "auth_user"
+ ]
+ migrations_apps = executor.loader.project_state(
+ ("migrations", "0001_initial"),
+ ).apps
+ global_apps.get_app_config("migrations").models[
+ "author"
+ ] = migrations_apps.get_model("migrations", "author")
+ try:
+ migration = executor.loader.get_migration("auth", "0001_initial")
+ self.assertIs(executor.detect_soft_applied(None, migration)[0], True)
+ finally:
+ connection.introspection.table_names = old_table_names
+ del global_apps.get_app_config("migrations").models["author"]
+ # Migrate back to clean up the database.
+ executor.loader.build_graph()
+ executor.migrate([("migrations", None)])
+ self.assertTableNotExists("migrations_author")
+ self.assertTableNotExists("migrations_tribble")
+
+ @override_settings(
+ MIGRATION_MODULES={
+ "migrations": "migrations.test_add_many_to_many_field_initial",
+ },
+ )
+ def test_detect_soft_applied_add_field_manytomanyfield(self):
+ """
+ executor.detect_soft_applied() detects ManyToManyField tables from an
+ AddField operation. This checks the case of AddField in a migration
+ with other operations (0001) and the case of AddField in its own
+ migration (0002).
+ """
+ tables = [
+ # from 0001
+ "migrations_project",
+ "migrations_task",
+ "migrations_project_tasks",
+ # from 0002
+ "migrations_task_projects",
+ ]
+ executor = MigrationExecutor(connection)
+ # Create the tables for 0001 but make it look like the migration hasn't
+ # been applied.
+ executor.migrate([("migrations", "0001_initial")])
+ executor.migrate([("migrations", None)], fake=True)
+ for table in tables[:3]:
+ self.assertTableExists(table)
+ # Table detection sees 0001 is applied but not 0002.
+ migration = executor.loader.get_migration("migrations", "0001_initial")
+ self.assertIs(executor.detect_soft_applied(None, migration)[0], True)
+ migration = executor.loader.get_migration("migrations", "0002_initial")
+ self.assertIs(executor.detect_soft_applied(None, migration)[0], False)
+
+ # Create the tables for both migrations but make it look like neither
+ # has been applied.
+ executor.loader.build_graph()
+ executor.migrate([("migrations", "0001_initial")], fake=True)
+ executor.migrate([("migrations", "0002_initial")])
+ executor.loader.build_graph()
+ executor.migrate([("migrations", None)], fake=True)
+ # Table detection sees 0002 is applied.
+ migration = executor.loader.get_migration("migrations", "0002_initial")
+ self.assertIs(executor.detect_soft_applied(None, migration)[0], True)
+
+ # Leave the tables for 0001 except the many-to-many table. That missing
+ # table should cause detect_soft_applied() to return False.
+ with connection.schema_editor() as editor:
+ for table in tables[2:]:
+ editor.execute(editor.sql_delete_table % {"table": table})
+ migration = executor.loader.get_migration("migrations", "0001_initial")
+ self.assertIs(executor.detect_soft_applied(None, migration)[0], False)
+
+ # Cleanup by removing the remaining tables.
+ with connection.schema_editor() as editor:
+ for table in tables[:2]:
+ editor.execute(editor.sql_delete_table % {"table": table})
+ for table in tables:
+ self.assertTableNotExists(table)
+
+ @override_settings(
+ INSTALLED_APPS=[
+ "migrations.migrations_test_apps.lookuperror_a",
+ "migrations.migrations_test_apps.lookuperror_b",
+ "migrations.migrations_test_apps.lookuperror_c",
+ ]
+ )
+ def test_unrelated_model_lookups_forwards(self):
+ """
+ #24123 - All models of apps already applied which are
+ unrelated to the first app being applied are part of the initial model
+ state.
+ """
+ try:
+ executor = MigrationExecutor(connection)
+ self.assertTableNotExists("lookuperror_a_a1")
+ self.assertTableNotExists("lookuperror_b_b1")
+ self.assertTableNotExists("lookuperror_c_c1")
+ executor.migrate([("lookuperror_b", "0003_b3")])
+ self.assertTableExists("lookuperror_b_b3")
+ # Rebuild the graph to reflect the new DB state
+ executor.loader.build_graph()
+
+ # Migrate forwards -- This led to a lookup LookupErrors because
+ # lookuperror_b.B2 is already applied
+ executor.migrate(
+ [
+ ("lookuperror_a", "0004_a4"),
+ ("lookuperror_c", "0003_c3"),
+ ]
+ )
+ self.assertTableExists("lookuperror_a_a4")
+ self.assertTableExists("lookuperror_c_c3")
+
+ # Rebuild the graph to reflect the new DB state
+ executor.loader.build_graph()
+ finally:
+ # Cleanup
+ executor.migrate(
+ [
+ ("lookuperror_a", None),
+ ("lookuperror_b", None),
+ ("lookuperror_c", None),
+ ]
+ )
+ self.assertTableNotExists("lookuperror_a_a1")
+ self.assertTableNotExists("lookuperror_b_b1")
+ self.assertTableNotExists("lookuperror_c_c1")
+
+ @override_settings(
+ INSTALLED_APPS=[
+ "migrations.migrations_test_apps.lookuperror_a",
+ "migrations.migrations_test_apps.lookuperror_b",
+ "migrations.migrations_test_apps.lookuperror_c",
+ ]
+ )
+ def test_unrelated_model_lookups_backwards(self):
+ """
+ #24123 - All models of apps being unapplied which are
+ unrelated to the first app being unapplied are part of the initial
+ model state.
+ """
+ try:
+ executor = MigrationExecutor(connection)
+ self.assertTableNotExists("lookuperror_a_a1")
+ self.assertTableNotExists("lookuperror_b_b1")
+ self.assertTableNotExists("lookuperror_c_c1")
+ executor.migrate(
+ [
+ ("lookuperror_a", "0004_a4"),
+ ("lookuperror_b", "0003_b3"),
+ ("lookuperror_c", "0003_c3"),
+ ]
+ )
+ self.assertTableExists("lookuperror_b_b3")
+ self.assertTableExists("lookuperror_a_a4")
+ self.assertTableExists("lookuperror_c_c3")
+ # Rebuild the graph to reflect the new DB state
+ executor.loader.build_graph()
+
+ # Migrate backwards -- This led to a lookup LookupErrors because
+ # lookuperror_b.B2 is not in the initial state (unrelated to app c)
+ executor.migrate([("lookuperror_a", None)])
+
+ # Rebuild the graph to reflect the new DB state
+ executor.loader.build_graph()
+ finally:
+ # Cleanup
+ executor.migrate([("lookuperror_b", None), ("lookuperror_c", None)])
+ self.assertTableNotExists("lookuperror_a_a1")
+ self.assertTableNotExists("lookuperror_b_b1")
+ self.assertTableNotExists("lookuperror_c_c1")
+
+ @override_settings(
+ INSTALLED_APPS=[
+ "migrations.migrations_test_apps.mutate_state_a",
+ "migrations.migrations_test_apps.mutate_state_b",
+ ]
+ )
+ def test_unrelated_applied_migrations_mutate_state(self):
+ """
+ #26647 - Unrelated applied migrations should be part of the final
+ state in both directions.
+ """
+ executor = MigrationExecutor(connection)
+ executor.migrate(
+ [
+ ("mutate_state_b", "0002_add_field"),
+ ]
+ )
+ # Migrate forward.
+ executor.loader.build_graph()
+ state = executor.migrate(
+ [
+ ("mutate_state_a", "0001_initial"),
+ ]
+ )
+ self.assertIn("added", state.models["mutate_state_b", "b"].fields)
+ executor.loader.build_graph()
+ # Migrate backward.
+ state = executor.migrate(
+ [
+ ("mutate_state_a", None),
+ ]
+ )
+ self.assertIn("added", state.models["mutate_state_b", "b"].fields)
+ executor.migrate(
+ [
+ ("mutate_state_b", None),
+ ]
+ )
+
+ @override_settings(MIGRATION_MODULES={"migrations": "migrations.test_migrations"})
+ def test_process_callback(self):
+ """
+ #24129 - Tests callback process
+ """
+ call_args_list = []
+
+ def callback(*args):
+ call_args_list.append(args)
+
+ executor = MigrationExecutor(connection, progress_callback=callback)
+ # Were the tables there before?
+ self.assertTableNotExists("migrations_author")
+ self.assertTableNotExists("migrations_tribble")
+ executor.migrate(
+ [
+ ("migrations", "0001_initial"),
+ ("migrations", "0002_second"),
+ ]
+ )
+ # Rebuild the graph to reflect the new DB state
+ executor.loader.build_graph()
+
+ executor.migrate(
+ [
+ ("migrations", None),
+ ("migrations", None),
+ ]
+ )
+ self.assertTableNotExists("migrations_author")
+ self.assertTableNotExists("migrations_tribble")
+
+ migrations = executor.loader.graph.nodes
+ expected = [
+ ("render_start",),
+ ("render_success",),
+ ("apply_start", migrations["migrations", "0001_initial"], False),
+ ("apply_success", migrations["migrations", "0001_initial"], False),
+ ("apply_start", migrations["migrations", "0002_second"], False),
+ ("apply_success", migrations["migrations", "0002_second"], False),
+ ("render_start",),
+ ("render_success",),
+ ("unapply_start", migrations["migrations", "0002_second"], False),
+ ("unapply_success", migrations["migrations", "0002_second"], False),
+ ("unapply_start", migrations["migrations", "0001_initial"], False),
+ ("unapply_success", migrations["migrations", "0001_initial"], False),
+ ]
+ self.assertEqual(call_args_list, expected)
+
+ @override_settings(
+ INSTALLED_APPS=[
+ "migrations.migrations_test_apps.alter_fk.author_app",
+ "migrations.migrations_test_apps.alter_fk.book_app",
+ ]
+ )
+ def test_alter_id_type_with_fk(self):
+ try:
+ executor = MigrationExecutor(connection)
+ self.assertTableNotExists("author_app_author")
+ self.assertTableNotExists("book_app_book")
+ # Apply initial migrations
+ executor.migrate(
+ [
+ ("author_app", "0001_initial"),
+ ("book_app", "0001_initial"),
+ ]
+ )
+ self.assertTableExists("author_app_author")
+ self.assertTableExists("book_app_book")
+ # Rebuild the graph to reflect the new DB state
+ executor.loader.build_graph()
+
+ # Apply PK type alteration
+ executor.migrate([("author_app", "0002_alter_id")])
+
+ # Rebuild the graph to reflect the new DB state
+ executor.loader.build_graph()
+ finally:
+ # We can't simply unapply the migrations here because there is no
+ # implicit cast from VARCHAR to INT on the database level.
+ with connection.schema_editor() as editor:
+ editor.execute(editor.sql_delete_table % {"table": "book_app_book"})
+ editor.execute(editor.sql_delete_table % {"table": "author_app_author"})
+ self.assertTableNotExists("author_app_author")
+ self.assertTableNotExists("book_app_book")
+ executor.migrate([("author_app", None)], fake=True)
+
+ @override_settings(
+ MIGRATION_MODULES={"migrations": "migrations.test_migrations_squashed"}
+ )
+ def test_apply_all_replaced_marks_replacement_as_applied(self):
+ """
+ Applying all replaced migrations marks replacement as applied (#24628).
+ """
+ recorder = MigrationRecorder(connection)
+ # Place the database in a state where the replaced migrations are
+ # partially applied: 0001 is applied, 0002 is not.
+ recorder.record_applied("migrations", "0001_initial")
+ executor = MigrationExecutor(connection)
+ # Use fake because we don't actually have the first migration
+ # applied, so the second will fail. And there's no need to actually
+ # create/modify tables here, we're just testing the
+ # MigrationRecord, which works the same with or without fake.
+ executor.migrate([("migrations", "0002_second")], fake=True)
+
+ # Because we've now applied 0001 and 0002 both, their squashed
+ # replacement should be marked as applied.
+ self.assertIn(
+ ("migrations", "0001_squashed_0002"),
+ recorder.applied_migrations(),
+ )
+
+ @override_settings(
+ MIGRATION_MODULES={"migrations": "migrations.test_migrations_squashed"}
+ )
+ def test_migrate_marks_replacement_applied_even_if_it_did_nothing(self):
+ """
+ A new squash migration will be marked as applied even if all its
+ replaced migrations were previously already applied (#24628).
+ """
+ recorder = MigrationRecorder(connection)
+ # Record all replaced migrations as applied
+ recorder.record_applied("migrations", "0001_initial")
+ recorder.record_applied("migrations", "0002_second")
+ executor = MigrationExecutor(connection)
+ executor.migrate([("migrations", "0001_squashed_0002")])
+
+ # Because 0001 and 0002 are both applied, even though this migrate run
+ # didn't apply anything new, their squashed replacement should be
+ # marked as applied.
+ self.assertIn(
+ ("migrations", "0001_squashed_0002"),
+ recorder.applied_migrations(),
+ )
+
+ @override_settings(
+ MIGRATION_MODULES={"migrations": "migrations.test_migrations_squashed"}
+ )
+ def test_migrate_marks_replacement_unapplied(self):
+ executor = MigrationExecutor(connection)
+ executor.migrate([("migrations", "0001_squashed_0002")])
+ try:
+ self.assertIn(
+ ("migrations", "0001_squashed_0002"),
+ executor.recorder.applied_migrations(),
+ )
+ finally:
+ executor.loader.build_graph()
+ executor.migrate([("migrations", None)])
+ self.assertNotIn(
+ ("migrations", "0001_squashed_0002"),
+ executor.recorder.applied_migrations(),
+ )
+
+ # When the feature is False, the operation and the record won't be
+ # performed in a transaction and the test will systematically pass.
+ @skipUnlessDBFeature("can_rollback_ddl")
+ def test_migrations_applied_and_recorded_atomically(self):
+ """Migrations are applied and recorded atomically."""
+
+ class Migration(migrations.Migration):
+ operations = [
+ migrations.CreateModel(
+ "model",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ],
+ ),
+ ]
+
+ executor = MigrationExecutor(connection)
+ with mock.patch(
+ "django.db.migrations.executor.MigrationExecutor.record_migration"
+ ) as record_migration:
+ record_migration.side_effect = RuntimeError("Recording migration failed.")
+ with self.assertRaisesMessage(RuntimeError, "Recording migration failed."):
+ executor.apply_migration(
+ ProjectState(),
+ Migration("0001_initial", "record_migration"),
+ )
+ executor.migrate([("migrations", "0001_initial")])
+ # The migration isn't recorded as applied since it failed.
+ migration_recorder = MigrationRecorder(connection)
+ self.assertIs(
+ migration_recorder.migration_qs.filter(
+ app="record_migration",
+ name="0001_initial",
+ ).exists(),
+ False,
+ )
+ self.assertTableNotExists("record_migration_model")
+
+ def test_migrations_not_applied_on_deferred_sql_failure(self):
+ """Migrations are not recorded if deferred SQL application fails."""
+
+ class DeferredSQL:
+ def __str__(self):
+ raise DatabaseError("Failed to apply deferred SQL")
+
+ class Migration(migrations.Migration):
+ atomic = False
+
+ def apply(self, project_state, schema_editor, collect_sql=False):
+ schema_editor.deferred_sql.append(DeferredSQL())
+
+ executor = MigrationExecutor(connection)
+ with self.assertRaisesMessage(DatabaseError, "Failed to apply deferred SQL"):
+ executor.apply_migration(
+ ProjectState(),
+ Migration("0001_initial", "deferred_sql"),
+ )
+ # The migration isn't recorded as applied since it failed.
+ migration_recorder = MigrationRecorder(connection)
+ self.assertIs(
+ migration_recorder.migration_qs.filter(
+ app="deferred_sql",
+ name="0001_initial",
+ ).exists(),
+ False,
+ )
+
+ @mock.patch.object(MigrationRecorder, "has_table", return_value=False)
+ def test_migrate_skips_schema_creation(self, mocked_has_table):
+ """
+ The django_migrations table is not created if there are no migrations
+ to record.
+ """
+ executor = MigrationExecutor(connection)
+ # 0 queries, since the query for has_table is being mocked.
+ with self.assertNumQueries(0):
+ executor.migrate([], plan=[])
+
+
+class FakeLoader:
+ def __init__(self, graph, applied):
+ self.graph = graph
+ self.applied_migrations = applied
+ self.replace_migrations = True
+
+
+class FakeMigration:
+ """Really all we need is any object with a debug-useful repr."""
+
+ def __init__(self, name):
+ self.name = name
+
+ def __repr__(self):
+ return "M<%s>" % self.name
+
+
+class ExecutorUnitTests(SimpleTestCase):
+ """(More) isolated unit tests for executor methods."""
+
+ def test_minimize_rollbacks(self):
+ """
+ Minimize unnecessary rollbacks in connected apps.
+
+ When you say "./manage.py migrate appA 0001", rather than migrating to
+ just after appA-0001 in the linearized migration plan (which could roll
+ back migrations in other apps that depend on appA 0001, but don't need
+ to be rolled back since we're not rolling back appA 0001), we migrate
+ to just before appA-0002.
+ """
+ a1_impl = FakeMigration("a1")
+ a1 = ("a", "1")
+ a2_impl = FakeMigration("a2")
+ a2 = ("a", "2")
+ b1_impl = FakeMigration("b1")
+ b1 = ("b", "1")
+ graph = MigrationGraph()
+ graph.add_node(a1, a1_impl)
+ graph.add_node(a2, a2_impl)
+ graph.add_node(b1, b1_impl)
+ graph.add_dependency(None, b1, a1)
+ graph.add_dependency(None, a2, a1)
+
+ executor = MigrationExecutor(None)
+ executor.loader = FakeLoader(
+ graph,
+ {
+ a1: a1_impl,
+ b1: b1_impl,
+ a2: a2_impl,
+ },
+ )
+
+ plan = executor.migration_plan({a1})
+
+ self.assertEqual(plan, [(a2_impl, True)])
+
+ def test_minimize_rollbacks_branchy(self):
+ r"""
+ Minimize rollbacks when target has multiple in-app children.
+
+ a: 1 <---- 3 <--\
+ \ \- 2 <--- 4
+ \ \
+ b: \- 1 <--- 2
+ """
+ a1_impl = FakeMigration("a1")
+ a1 = ("a", "1")
+ a2_impl = FakeMigration("a2")
+ a2 = ("a", "2")
+ a3_impl = FakeMigration("a3")
+ a3 = ("a", "3")
+ a4_impl = FakeMigration("a4")
+ a4 = ("a", "4")
+ b1_impl = FakeMigration("b1")
+ b1 = ("b", "1")
+ b2_impl = FakeMigration("b2")
+ b2 = ("b", "2")
+ graph = MigrationGraph()
+ graph.add_node(a1, a1_impl)
+ graph.add_node(a2, a2_impl)
+ graph.add_node(a3, a3_impl)
+ graph.add_node(a4, a4_impl)
+ graph.add_node(b1, b1_impl)
+ graph.add_node(b2, b2_impl)
+ graph.add_dependency(None, a2, a1)
+ graph.add_dependency(None, a3, a1)
+ graph.add_dependency(None, a4, a2)
+ graph.add_dependency(None, a4, a3)
+ graph.add_dependency(None, b2, b1)
+ graph.add_dependency(None, b1, a1)
+ graph.add_dependency(None, b2, a2)
+
+ executor = MigrationExecutor(None)
+ executor.loader = FakeLoader(
+ graph,
+ {
+ a1: a1_impl,
+ b1: b1_impl,
+ a2: a2_impl,
+ b2: b2_impl,
+ a3: a3_impl,
+ a4: a4_impl,
+ },
+ )
+
+ plan = executor.migration_plan({a1})
+
+ should_be_rolled_back = [b2_impl, a4_impl, a2_impl, a3_impl]
+ exp = [(m, True) for m in should_be_rolled_back]
+ self.assertEqual(plan, exp)
+
+ def test_backwards_nothing_to_do(self):
+ r"""
+ If the current state satisfies the given target, do nothing.
+
+ a: 1 <--- 2
+ b: \- 1
+ c: \- 1
+
+ If a1 is applied already and a2 is not, and we're asked to migrate to
+ a1, don't apply or unapply b1 or c1, regardless of their current state.
+ """
+ a1_impl = FakeMigration("a1")
+ a1 = ("a", "1")
+ a2_impl = FakeMigration("a2")
+ a2 = ("a", "2")
+ b1_impl = FakeMigration("b1")
+ b1 = ("b", "1")
+ c1_impl = FakeMigration("c1")
+ c1 = ("c", "1")
+ graph = MigrationGraph()
+ graph.add_node(a1, a1_impl)
+ graph.add_node(a2, a2_impl)
+ graph.add_node(b1, b1_impl)
+ graph.add_node(c1, c1_impl)
+ graph.add_dependency(None, a2, a1)
+ graph.add_dependency(None, b1, a1)
+ graph.add_dependency(None, c1, a1)
+
+ executor = MigrationExecutor(None)
+ executor.loader = FakeLoader(
+ graph,
+ {
+ a1: a1_impl,
+ b1: b1_impl,
+ },
+ )
+
+ plan = executor.migration_plan({a1})
+
+ self.assertEqual(plan, [])
diff --git a/testbed/django__django/tests/migrations/test_fake_initial_case_insensitive/fake_initial/0001_initial.py b/testbed/django__django/tests/migrations/test_fake_initial_case_insensitive/fake_initial/0001_initial.py
new file mode 100644
index 0000000000000000000000000000000000000000..6fd6a0d435c0175b0e65cec501b1a9ea2fd5a162
--- /dev/null
+++ b/testbed/django__django/tests/migrations/test_fake_initial_case_insensitive/fake_initial/0001_initial.py
@@ -0,0 +1,30 @@
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+ initial = True
+
+ operations = [
+ migrations.CreateModel(
+ "fakeinitialmodel",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ("field", models.CharField(max_length=20)),
+ ],
+ options={
+ "db_table": "migrations_mIxEd_cAsE_mOdEl",
+ },
+ ),
+ migrations.AddField(
+ model_name="fakeinitialmodel",
+ name="field_mixed_case",
+ field=models.CharField(max_length=20, db_column="fIeLd_mIxEd_cAsE"),
+ ),
+ migrations.AddField(
+ model_name="fakeinitialmodel",
+ name="fake_initial_model",
+ field=models.ManyToManyField(
+ to="migrations.fakeinitialmodel", db_table="m2m_mIxEd_cAsE"
+ ),
+ ),
+ ]
diff --git a/testbed/django__django/tests/migrations/test_fake_initial_case_insensitive/fake_initial/__init__.py b/testbed/django__django/tests/migrations/test_fake_initial_case_insensitive/fake_initial/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testbed/django__django/tests/migrations/test_fake_initial_case_insensitive/initial/0001_initial.py b/testbed/django__django/tests/migrations/test_fake_initial_case_insensitive/initial/0001_initial.py
new file mode 100644
index 0000000000000000000000000000000000000000..e3c1fc8d18c022c89c621503a368228bdc3edc38
--- /dev/null
+++ b/testbed/django__django/tests/migrations/test_fake_initial_case_insensitive/initial/0001_initial.py
@@ -0,0 +1,28 @@
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+ initial = True
+
+ operations = [
+ migrations.CreateModel(
+ name="fakeinitialmodel",
+ fields=[
+ ("id", models.AutoField(primary_key=True)),
+ ("field", models.CharField(max_length=20)),
+ (
+ "field_mixed_case",
+ models.CharField(max_length=20, db_column="FiEld_MiXeD_CaSe"),
+ ),
+ (
+ "fake_initial_mode",
+ models.ManyToManyField(
+ "migrations.FakeInitialModel", db_table="m2m_MiXeD_CaSe"
+ ),
+ ),
+ ],
+ options={
+ "db_table": "migrations_MiXeD_CaSe_MoDel",
+ },
+ ),
+ ]
diff --git a/testbed/django__django/tests/migrations/test_fake_initial_case_insensitive/initial/__init__.py b/testbed/django__django/tests/migrations/test_fake_initial_case_insensitive/initial/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testbed/django__django/tests/migrations/test_graph.py b/testbed/django__django/tests/migrations/test_graph.py
new file mode 100644
index 0000000000000000000000000000000000000000..033a5978e2b9f75cf32f4ef55f9214f4112d5566
--- /dev/null
+++ b/testbed/django__django/tests/migrations/test_graph.py
@@ -0,0 +1,473 @@
+from django.db.migrations.exceptions import CircularDependencyError, NodeNotFoundError
+from django.db.migrations.graph import DummyNode, MigrationGraph, Node
+from django.test import SimpleTestCase
+
+
+class GraphTests(SimpleTestCase):
+ """
+ Tests the digraph structure.
+ """
+
+ def test_simple_graph(self):
+ """
+ Tests a basic dependency graph:
+
+ app_a: 0001 <-- 0002 <--- 0003 <-- 0004
+ /
+ app_b: 0001 <-- 0002 <-/
+ """
+ # Build graph
+ graph = MigrationGraph()
+ graph.add_node(("app_a", "0001"), None)
+ graph.add_node(("app_a", "0002"), None)
+ graph.add_node(("app_a", "0003"), None)
+ graph.add_node(("app_a", "0004"), None)
+ graph.add_node(("app_b", "0001"), None)
+ graph.add_node(("app_b", "0002"), None)
+ graph.add_dependency("app_a.0004", ("app_a", "0004"), ("app_a", "0003"))
+ graph.add_dependency("app_a.0003", ("app_a", "0003"), ("app_a", "0002"))
+ graph.add_dependency("app_a.0002", ("app_a", "0002"), ("app_a", "0001"))
+ graph.add_dependency("app_a.0003", ("app_a", "0003"), ("app_b", "0002"))
+ graph.add_dependency("app_b.0002", ("app_b", "0002"), ("app_b", "0001"))
+ # Test root migration case
+ self.assertEqual(
+ graph.forwards_plan(("app_a", "0001")),
+ [("app_a", "0001")],
+ )
+ # Test branch B only
+ self.assertEqual(
+ graph.forwards_plan(("app_b", "0002")),
+ [("app_b", "0001"), ("app_b", "0002")],
+ )
+ # Test whole graph
+ self.assertEqual(
+ graph.forwards_plan(("app_a", "0004")),
+ [
+ ("app_b", "0001"),
+ ("app_b", "0002"),
+ ("app_a", "0001"),
+ ("app_a", "0002"),
+ ("app_a", "0003"),
+ ("app_a", "0004"),
+ ],
+ )
+ # Test reverse to b:0002
+ self.assertEqual(
+ graph.backwards_plan(("app_b", "0002")),
+ [("app_a", "0004"), ("app_a", "0003"), ("app_b", "0002")],
+ )
+ # Test roots and leaves
+ self.assertEqual(
+ graph.root_nodes(),
+ [("app_a", "0001"), ("app_b", "0001")],
+ )
+ self.assertEqual(
+ graph.leaf_nodes(),
+ [("app_a", "0004"), ("app_b", "0002")],
+ )
+
+ def test_complex_graph(self):
+ r"""
+ Tests a complex dependency graph:
+
+ app_a: 0001 <-- 0002 <--- 0003 <-- 0004
+ \ \ / /
+ app_b: 0001 <-\ 0002 <-X /
+ \ \ /
+ app_c: \ 0001 <-- 0002 <-
+ """
+ # Build graph
+ graph = MigrationGraph()
+ graph.add_node(("app_a", "0001"), None)
+ graph.add_node(("app_a", "0002"), None)
+ graph.add_node(("app_a", "0003"), None)
+ graph.add_node(("app_a", "0004"), None)
+ graph.add_node(("app_b", "0001"), None)
+ graph.add_node(("app_b", "0002"), None)
+ graph.add_node(("app_c", "0001"), None)
+ graph.add_node(("app_c", "0002"), None)
+ graph.add_dependency("app_a.0004", ("app_a", "0004"), ("app_a", "0003"))
+ graph.add_dependency("app_a.0003", ("app_a", "0003"), ("app_a", "0002"))
+ graph.add_dependency("app_a.0002", ("app_a", "0002"), ("app_a", "0001"))
+ graph.add_dependency("app_a.0003", ("app_a", "0003"), ("app_b", "0002"))
+ graph.add_dependency("app_b.0002", ("app_b", "0002"), ("app_b", "0001"))
+ graph.add_dependency("app_a.0004", ("app_a", "0004"), ("app_c", "0002"))
+ graph.add_dependency("app_c.0002", ("app_c", "0002"), ("app_c", "0001"))
+ graph.add_dependency("app_c.0001", ("app_c", "0001"), ("app_b", "0001"))
+ graph.add_dependency("app_c.0002", ("app_c", "0002"), ("app_a", "0002"))
+ # Test branch C only
+ self.assertEqual(
+ graph.forwards_plan(("app_c", "0002")),
+ [
+ ("app_b", "0001"),
+ ("app_c", "0001"),
+ ("app_a", "0001"),
+ ("app_a", "0002"),
+ ("app_c", "0002"),
+ ],
+ )
+ # Test whole graph
+ self.assertEqual(
+ graph.forwards_plan(("app_a", "0004")),
+ [
+ ("app_b", "0001"),
+ ("app_c", "0001"),
+ ("app_a", "0001"),
+ ("app_a", "0002"),
+ ("app_c", "0002"),
+ ("app_b", "0002"),
+ ("app_a", "0003"),
+ ("app_a", "0004"),
+ ],
+ )
+ # Test reverse to b:0001
+ self.assertEqual(
+ graph.backwards_plan(("app_b", "0001")),
+ [
+ ("app_a", "0004"),
+ ("app_c", "0002"),
+ ("app_c", "0001"),
+ ("app_a", "0003"),
+ ("app_b", "0002"),
+ ("app_b", "0001"),
+ ],
+ )
+ # Test roots and leaves
+ self.assertEqual(
+ graph.root_nodes(),
+ [("app_a", "0001"), ("app_b", "0001"), ("app_c", "0001")],
+ )
+ self.assertEqual(
+ graph.leaf_nodes(),
+ [("app_a", "0004"), ("app_b", "0002"), ("app_c", "0002")],
+ )
+
+ def test_circular_graph(self):
+ """
+ Tests a circular dependency graph.
+ """
+ # Build graph
+ graph = MigrationGraph()
+ graph.add_node(("app_a", "0001"), None)
+ graph.add_node(("app_a", "0002"), None)
+ graph.add_node(("app_a", "0003"), None)
+ graph.add_node(("app_b", "0001"), None)
+ graph.add_node(("app_b", "0002"), None)
+ graph.add_dependency("app_a.0003", ("app_a", "0003"), ("app_a", "0002"))
+ graph.add_dependency("app_a.0002", ("app_a", "0002"), ("app_a", "0001"))
+ graph.add_dependency("app_a.0001", ("app_a", "0001"), ("app_b", "0002"))
+ graph.add_dependency("app_b.0002", ("app_b", "0002"), ("app_b", "0001"))
+ graph.add_dependency("app_b.0001", ("app_b", "0001"), ("app_a", "0003"))
+ # Test whole graph
+ with self.assertRaises(CircularDependencyError):
+ graph.ensure_not_cyclic()
+
+ def test_circular_graph_2(self):
+ graph = MigrationGraph()
+ graph.add_node(("A", "0001"), None)
+ graph.add_node(("C", "0001"), None)
+ graph.add_node(("B", "0001"), None)
+ graph.add_dependency("A.0001", ("A", "0001"), ("B", "0001"))
+ graph.add_dependency("B.0001", ("B", "0001"), ("A", "0001"))
+ graph.add_dependency("C.0001", ("C", "0001"), ("B", "0001"))
+
+ with self.assertRaises(CircularDependencyError):
+ graph.ensure_not_cyclic()
+
+ def test_iterative_dfs(self):
+ graph = MigrationGraph()
+ root = ("app_a", "1")
+ graph.add_node(root, None)
+ expected = [root]
+ for i in range(2, 750):
+ parent = ("app_a", str(i - 1))
+ child = ("app_a", str(i))
+ graph.add_node(child, None)
+ graph.add_dependency(str(i), child, parent)
+ expected.append(child)
+ leaf = expected[-1]
+
+ forwards_plan = graph.forwards_plan(leaf)
+ self.assertEqual(expected, forwards_plan)
+
+ backwards_plan = graph.backwards_plan(root)
+ self.assertEqual(expected[::-1], backwards_plan)
+
+ def test_iterative_dfs_complexity(self):
+ """
+ In a graph with merge migrations, iterative_dfs() traverses each node
+ only once even if there are multiple paths leading to it.
+ """
+ n = 50
+ graph = MigrationGraph()
+ for i in range(1, n + 1):
+ graph.add_node(("app_a", str(i)), None)
+ graph.add_node(("app_b", str(i)), None)
+ graph.add_node(("app_c", str(i)), None)
+ for i in range(1, n):
+ graph.add_dependency(None, ("app_b", str(i)), ("app_a", str(i)))
+ graph.add_dependency(None, ("app_c", str(i)), ("app_a", str(i)))
+ graph.add_dependency(None, ("app_a", str(i + 1)), ("app_b", str(i)))
+ graph.add_dependency(None, ("app_a", str(i + 1)), ("app_c", str(i)))
+ plan = graph.forwards_plan(("app_a", str(n)))
+ expected = [
+ (app, str(i)) for i in range(1, n) for app in ["app_a", "app_c", "app_b"]
+ ] + [("app_a", str(n))]
+ self.assertEqual(plan, expected)
+
+ def test_plan_invalid_node(self):
+ """
+ Tests for forwards/backwards_plan of nonexistent node.
+ """
+ graph = MigrationGraph()
+ message = "Node ('app_b', '0001') not a valid node"
+
+ with self.assertRaisesMessage(NodeNotFoundError, message):
+ graph.forwards_plan(("app_b", "0001"))
+
+ with self.assertRaisesMessage(NodeNotFoundError, message):
+ graph.backwards_plan(("app_b", "0001"))
+
+ def test_missing_parent_nodes(self):
+ """
+ Tests for missing parent nodes.
+ """
+ # Build graph
+ graph = MigrationGraph()
+ graph.add_node(("app_a", "0001"), None)
+ graph.add_node(("app_a", "0002"), None)
+ graph.add_node(("app_a", "0003"), None)
+ graph.add_node(("app_b", "0001"), None)
+ graph.add_dependency("app_a.0003", ("app_a", "0003"), ("app_a", "0002"))
+ graph.add_dependency("app_a.0002", ("app_a", "0002"), ("app_a", "0001"))
+ msg = (
+ "Migration app_a.0001 dependencies reference nonexistent parent node "
+ "('app_b', '0002')"
+ )
+ with self.assertRaisesMessage(NodeNotFoundError, msg):
+ graph.add_dependency("app_a.0001", ("app_a", "0001"), ("app_b", "0002"))
+
+ def test_missing_child_nodes(self):
+ """
+ Tests for missing child nodes.
+ """
+ # Build graph
+ graph = MigrationGraph()
+ graph.add_node(("app_a", "0001"), None)
+ msg = (
+ "Migration app_a.0002 dependencies reference nonexistent child node "
+ "('app_a', '0002')"
+ )
+ with self.assertRaisesMessage(NodeNotFoundError, msg):
+ graph.add_dependency("app_a.0002", ("app_a", "0002"), ("app_a", "0001"))
+
+ def test_validate_consistency_missing_parent(self):
+ graph = MigrationGraph()
+ graph.add_node(("app_a", "0001"), None)
+ graph.add_dependency(
+ "app_a.0001", ("app_a", "0001"), ("app_b", "0002"), skip_validation=True
+ )
+ msg = (
+ "Migration app_a.0001 dependencies reference nonexistent parent node "
+ "('app_b', '0002')"
+ )
+ with self.assertRaisesMessage(NodeNotFoundError, msg):
+ graph.validate_consistency()
+
+ def test_validate_consistency_missing_child(self):
+ graph = MigrationGraph()
+ graph.add_node(("app_b", "0002"), None)
+ graph.add_dependency(
+ "app_b.0002", ("app_a", "0001"), ("app_b", "0002"), skip_validation=True
+ )
+ msg = (
+ "Migration app_b.0002 dependencies reference nonexistent child node "
+ "('app_a', '0001')"
+ )
+ with self.assertRaisesMessage(NodeNotFoundError, msg):
+ graph.validate_consistency()
+
+ def test_validate_consistency_no_error(self):
+ graph = MigrationGraph()
+ graph.add_node(("app_a", "0001"), None)
+ graph.add_node(("app_b", "0002"), None)
+ graph.add_dependency(
+ "app_a.0001", ("app_a", "0001"), ("app_b", "0002"), skip_validation=True
+ )
+ graph.validate_consistency()
+
+ def test_validate_consistency_dummy(self):
+ """
+ validate_consistency() raises an error if there's an isolated dummy
+ node.
+ """
+ msg = "app_a.0001 (req'd by app_b.0002) is missing!"
+ graph = MigrationGraph()
+ graph.add_dummy_node(
+ key=("app_a", "0001"), origin="app_b.0002", error_message=msg
+ )
+ with self.assertRaisesMessage(NodeNotFoundError, msg):
+ graph.validate_consistency()
+
+ def test_remove_replaced_nodes(self):
+ """
+ Replaced nodes are properly removed and dependencies remapped.
+ """
+ # Add some dummy nodes to be replaced.
+ graph = MigrationGraph()
+ graph.add_dummy_node(
+ key=("app_a", "0001"), origin="app_a.0002", error_message="BAD!"
+ )
+ graph.add_dummy_node(
+ key=("app_a", "0002"), origin="app_b.0001", error_message="BAD!"
+ )
+ graph.add_dependency(
+ "app_a.0002", ("app_a", "0002"), ("app_a", "0001"), skip_validation=True
+ )
+ # Add some normal parent and child nodes to test dependency remapping.
+ graph.add_node(("app_c", "0001"), None)
+ graph.add_node(("app_b", "0001"), None)
+ graph.add_dependency(
+ "app_a.0001", ("app_a", "0001"), ("app_c", "0001"), skip_validation=True
+ )
+ graph.add_dependency(
+ "app_b.0001", ("app_b", "0001"), ("app_a", "0002"), skip_validation=True
+ )
+ # Try replacing before replacement node exists.
+ msg = (
+ "Unable to find replacement node ('app_a', '0001_squashed_0002'). It was "
+ "either never added to the migration graph, or has been removed."
+ )
+ with self.assertRaisesMessage(NodeNotFoundError, msg):
+ graph.remove_replaced_nodes(
+ replacement=("app_a", "0001_squashed_0002"),
+ replaced=[("app_a", "0001"), ("app_a", "0002")],
+ )
+ graph.add_node(("app_a", "0001_squashed_0002"), None)
+ # Ensure `validate_consistency()` still raises an error at this stage.
+ with self.assertRaisesMessage(NodeNotFoundError, "BAD!"):
+ graph.validate_consistency()
+ # Remove the dummy nodes.
+ graph.remove_replaced_nodes(
+ replacement=("app_a", "0001_squashed_0002"),
+ replaced=[("app_a", "0001"), ("app_a", "0002")],
+ )
+ # Ensure graph is now consistent and dependencies have been remapped
+ graph.validate_consistency()
+ parent_node = graph.node_map[("app_c", "0001")]
+ replacement_node = graph.node_map[("app_a", "0001_squashed_0002")]
+ child_node = graph.node_map[("app_b", "0001")]
+ self.assertIn(parent_node, replacement_node.parents)
+ self.assertIn(replacement_node, parent_node.children)
+ self.assertIn(child_node, replacement_node.children)
+ self.assertIn(replacement_node, child_node.parents)
+
+ def test_remove_replacement_node(self):
+ """
+ A replacement node is properly removed and child dependencies remapped.
+ We assume parent dependencies are already correct.
+ """
+ # Add some dummy nodes to be replaced.
+ graph = MigrationGraph()
+ graph.add_node(("app_a", "0001"), None)
+ graph.add_node(("app_a", "0002"), None)
+ graph.add_dependency("app_a.0002", ("app_a", "0002"), ("app_a", "0001"))
+ # Try removing replacement node before replacement node exists.
+ msg = (
+ "Unable to remove replacement node ('app_a', '0001_squashed_0002'). It was"
+ " either never added to the migration graph, or has been removed already."
+ )
+ with self.assertRaisesMessage(NodeNotFoundError, msg):
+ graph.remove_replacement_node(
+ replacement=("app_a", "0001_squashed_0002"),
+ replaced=[("app_a", "0001"), ("app_a", "0002")],
+ )
+ graph.add_node(("app_a", "0001_squashed_0002"), None)
+ # Add a child node to test dependency remapping.
+ graph.add_node(("app_b", "0001"), None)
+ graph.add_dependency(
+ "app_b.0001", ("app_b", "0001"), ("app_a", "0001_squashed_0002")
+ )
+ # Remove the replacement node.
+ graph.remove_replacement_node(
+ replacement=("app_a", "0001_squashed_0002"),
+ replaced=[("app_a", "0001"), ("app_a", "0002")],
+ )
+ # Ensure graph is consistent and child dependency has been remapped
+ graph.validate_consistency()
+ replaced_node = graph.node_map[("app_a", "0002")]
+ child_node = graph.node_map[("app_b", "0001")]
+ self.assertIn(child_node, replaced_node.children)
+ self.assertIn(replaced_node, child_node.parents)
+ # Child dependency hasn't also gotten remapped to the other replaced
+ # node.
+ other_replaced_node = graph.node_map[("app_a", "0001")]
+ self.assertNotIn(child_node, other_replaced_node.children)
+ self.assertNotIn(other_replaced_node, child_node.parents)
+
+ def test_infinite_loop(self):
+ """
+ Tests a complex dependency graph:
+
+ app_a: 0001 <-
+ \
+ app_b: 0001 <- x 0002 <-
+ / \
+ app_c: 0001<- <------------- x 0002
+
+ And apply squashing on app_c.
+ """
+ graph = MigrationGraph()
+
+ graph.add_node(("app_a", "0001"), None)
+ graph.add_node(("app_b", "0001"), None)
+ graph.add_node(("app_b", "0002"), None)
+ graph.add_node(("app_c", "0001_squashed_0002"), None)
+
+ graph.add_dependency(
+ "app_b.0001", ("app_b", "0001"), ("app_c", "0001_squashed_0002")
+ )
+ graph.add_dependency("app_b.0002", ("app_b", "0002"), ("app_a", "0001"))
+ graph.add_dependency("app_b.0002", ("app_b", "0002"), ("app_b", "0001"))
+ graph.add_dependency(
+ "app_c.0001_squashed_0002",
+ ("app_c", "0001_squashed_0002"),
+ ("app_b", "0002"),
+ )
+
+ with self.assertRaises(CircularDependencyError):
+ graph.ensure_not_cyclic()
+
+ def test_stringify(self):
+ graph = MigrationGraph()
+ self.assertEqual(str(graph), "Graph: 0 nodes, 0 edges")
+
+ graph.add_node(("app_a", "0001"), None)
+ graph.add_node(("app_a", "0002"), None)
+ graph.add_node(("app_a", "0003"), None)
+ graph.add_node(("app_b", "0001"), None)
+ graph.add_node(("app_b", "0002"), None)
+ graph.add_dependency("app_a.0002", ("app_a", "0002"), ("app_a", "0001"))
+ graph.add_dependency("app_a.0003", ("app_a", "0003"), ("app_a", "0002"))
+ graph.add_dependency("app_a.0003", ("app_a", "0003"), ("app_b", "0002"))
+
+ self.assertEqual(str(graph), "Graph: 5 nodes, 3 edges")
+ self.assertEqual(repr(graph), "")
+
+
+class NodeTests(SimpleTestCase):
+ def test_node_repr(self):
+ node = Node(("app_a", "0001"))
+ self.assertEqual(repr(node), "")
+
+ def test_node_str(self):
+ node = Node(("app_a", "0001"))
+ self.assertEqual(str(node), "('app_a', '0001')")
+
+ def test_dummynode_repr(self):
+ node = DummyNode(
+ key=("app_a", "0001"),
+ origin="app_a.0001",
+ error_message="x is missing",
+ )
+ self.assertEqual(repr(node), "")
diff --git a/testbed/django__django/tests/migrations/test_loader.py b/testbed/django__django/tests/migrations/test_loader.py
new file mode 100644
index 0000000000000000000000000000000000000000..3b30aed100712911e71fa8939653e963635b61e9
--- /dev/null
+++ b/testbed/django__django/tests/migrations/test_loader.py
@@ -0,0 +1,685 @@
+import compileall
+import os
+from importlib import import_module
+
+from django.db import connection, connections
+from django.db.migrations.exceptions import (
+ AmbiguityError,
+ InconsistentMigrationHistory,
+ NodeNotFoundError,
+)
+from django.db.migrations.loader import MigrationLoader
+from django.db.migrations.recorder import MigrationRecorder
+from django.test import TestCase, modify_settings, override_settings
+
+from .test_base import MigrationTestBase
+
+
+class RecorderTests(TestCase):
+ """
+ Tests recording migrations as applied or not.
+ """
+
+ databases = {"default", "other"}
+
+ def test_apply(self):
+ """
+ Tests marking migrations as applied/unapplied.
+ """
+ recorder = MigrationRecorder(connection)
+ self.assertEqual(
+ {(x, y) for (x, y) in recorder.applied_migrations() if x == "myapp"},
+ set(),
+ )
+ recorder.record_applied("myapp", "0432_ponies")
+ self.assertEqual(
+ {(x, y) for (x, y) in recorder.applied_migrations() if x == "myapp"},
+ {("myapp", "0432_ponies")},
+ )
+ # That should not affect records of another database
+ recorder_other = MigrationRecorder(connections["other"])
+ self.assertEqual(
+ {(x, y) for (x, y) in recorder_other.applied_migrations() if x == "myapp"},
+ set(),
+ )
+ recorder.record_unapplied("myapp", "0432_ponies")
+ self.assertEqual(
+ {(x, y) for (x, y) in recorder.applied_migrations() if x == "myapp"},
+ set(),
+ )
+
+ def test_has_table_cached(self):
+ """
+ The has_table() method caches a positive result and not continually
+ query for the existence of the migrations table.
+ """
+ recorder = MigrationRecorder(connection)
+ self.assertIs(recorder.has_table(), True)
+ with self.assertNumQueries(0):
+ self.assertIs(recorder.has_table(), True)
+
+
+class LoaderTests(TestCase):
+ """
+ Tests the disk and database loader, and running through migrations
+ in memory.
+ """
+
+ def setUp(self):
+ self.applied_records = []
+
+ def tearDown(self):
+ # Unapply records on databases that don't roll back changes after each
+ # test method.
+ if not connection.features.supports_transactions:
+ for recorder, app, name in self.applied_records:
+ recorder.record_unapplied(app, name)
+
+ def record_applied(self, recorder, app, name):
+ recorder.record_applied(app, name)
+ self.applied_records.append((recorder, app, name))
+
+ @override_settings(MIGRATION_MODULES={"migrations": "migrations.test_migrations"})
+ @modify_settings(INSTALLED_APPS={"append": "basic"})
+ def test_load(self):
+ """
+ Makes sure the loader can load the migrations for the test apps,
+ and then render them out to a new Apps.
+ """
+ # Load and test the plan
+ migration_loader = MigrationLoader(connection)
+ self.assertEqual(
+ migration_loader.graph.forwards_plan(("migrations", "0002_second")),
+ [
+ ("migrations", "0001_initial"),
+ ("migrations", "0002_second"),
+ ],
+ )
+ # Now render it out!
+ project_state = migration_loader.project_state(("migrations", "0002_second"))
+ self.assertEqual(len(project_state.models), 2)
+
+ author_state = project_state.models["migrations", "author"]
+ self.assertEqual(
+ list(author_state.fields), ["id", "name", "slug", "age", "rating"]
+ )
+
+ book_state = project_state.models["migrations", "book"]
+ self.assertEqual(list(book_state.fields), ["id", "author"])
+
+ # Ensure we've included unmigrated apps in there too
+ self.assertIn("basic", project_state.real_apps)
+
+ @override_settings(
+ MIGRATION_MODULES={
+ "migrations": "migrations.test_migrations",
+ "migrations2": "migrations2.test_migrations_2",
+ }
+ )
+ @modify_settings(INSTALLED_APPS={"append": "migrations2"})
+ def test_plan_handles_repeated_migrations(self):
+ """
+ _generate_plan() doesn't readd migrations already in the plan (#29180).
+ """
+ migration_loader = MigrationLoader(connection)
+ nodes = [("migrations", "0002_second"), ("migrations2", "0001_initial")]
+ self.assertEqual(
+ migration_loader.graph._generate_plan(nodes, at_end=True),
+ [
+ ("migrations", "0001_initial"),
+ ("migrations", "0002_second"),
+ ("migrations2", "0001_initial"),
+ ],
+ )
+
+ @override_settings(
+ MIGRATION_MODULES={"migrations": "migrations.test_migrations_unmigdep"}
+ )
+ def test_load_unmigrated_dependency(self):
+ """
+ The loader can load migrations with a dependency on an unmigrated app.
+ """
+ # Load and test the plan
+ migration_loader = MigrationLoader(connection)
+ self.assertEqual(
+ migration_loader.graph.forwards_plan(("migrations", "0001_initial")),
+ [
+ ("contenttypes", "0001_initial"),
+ ("auth", "0001_initial"),
+ ("migrations", "0001_initial"),
+ ],
+ )
+ # Now render it out!
+ project_state = migration_loader.project_state(("migrations", "0001_initial"))
+ self.assertEqual(
+ len([m for a, m in project_state.models if a == "migrations"]), 1
+ )
+
+ book_state = project_state.models["migrations", "book"]
+ self.assertEqual(list(book_state.fields), ["id", "user"])
+
+ @override_settings(
+ MIGRATION_MODULES={"migrations": "migrations.test_migrations_run_before"}
+ )
+ def test_run_before(self):
+ """
+ Makes sure the loader uses Migration.run_before.
+ """
+ # Load and test the plan
+ migration_loader = MigrationLoader(connection)
+ self.assertEqual(
+ migration_loader.graph.forwards_plan(("migrations", "0002_second")),
+ [
+ ("migrations", "0001_initial"),
+ ("migrations", "0003_third"),
+ ("migrations", "0002_second"),
+ ],
+ )
+
+ @override_settings(
+ MIGRATION_MODULES={
+ "migrations": "migrations.test_migrations_first",
+ "migrations2": "migrations2.test_migrations_2_first",
+ }
+ )
+ @modify_settings(INSTALLED_APPS={"append": "migrations2"})
+ def test_first(self):
+ """
+ Makes sure the '__first__' migrations build correctly.
+ """
+ migration_loader = MigrationLoader(connection)
+ self.assertEqual(
+ migration_loader.graph.forwards_plan(("migrations", "second")),
+ [
+ ("migrations", "thefirst"),
+ ("migrations2", "0001_initial"),
+ ("migrations2", "0002_second"),
+ ("migrations", "second"),
+ ],
+ )
+
+ @override_settings(MIGRATION_MODULES={"migrations": "migrations.test_migrations"})
+ def test_name_match(self):
+ "Tests prefix name matching"
+ migration_loader = MigrationLoader(connection)
+ self.assertEqual(
+ migration_loader.get_migration_by_prefix("migrations", "0001").name,
+ "0001_initial",
+ )
+ msg = "There is more than one migration for 'migrations' with the prefix '0'"
+ with self.assertRaisesMessage(AmbiguityError, msg):
+ migration_loader.get_migration_by_prefix("migrations", "0")
+ msg = "There is no migration for 'migrations' with the prefix 'blarg'"
+ with self.assertRaisesMessage(KeyError, msg):
+ migration_loader.get_migration_by_prefix("migrations", "blarg")
+
+ def test_load_import_error(self):
+ with override_settings(
+ MIGRATION_MODULES={"migrations": "import_error_package"}
+ ):
+ with self.assertRaises(ImportError):
+ MigrationLoader(connection)
+
+ def test_load_module_file(self):
+ with override_settings(
+ MIGRATION_MODULES={"migrations": "migrations.faulty_migrations.file"}
+ ):
+ loader = MigrationLoader(connection)
+ self.assertIn(
+ "migrations",
+ loader.unmigrated_apps,
+ "App with migrations module file not in unmigrated apps.",
+ )
+
+ def test_load_empty_dir(self):
+ with override_settings(
+ MIGRATION_MODULES={"migrations": "migrations.faulty_migrations.namespace"}
+ ):
+ loader = MigrationLoader(connection)
+ self.assertIn(
+ "migrations",
+ loader.unmigrated_apps,
+ "App missing __init__.py in migrations module not in unmigrated apps.",
+ )
+
+ @override_settings(
+ INSTALLED_APPS=["migrations.migrations_test_apps.migrated_app"],
+ )
+ def test_marked_as_migrated(self):
+ """
+ Undefined MIGRATION_MODULES implies default migration module.
+ """
+ migration_loader = MigrationLoader(connection)
+ self.assertEqual(migration_loader.migrated_apps, {"migrated_app"})
+ self.assertEqual(migration_loader.unmigrated_apps, set())
+
+ @override_settings(
+ INSTALLED_APPS=["migrations.migrations_test_apps.migrated_app"],
+ MIGRATION_MODULES={"migrated_app": None},
+ )
+ def test_marked_as_unmigrated(self):
+ """
+ MIGRATION_MODULES allows disabling of migrations for a particular app.
+ """
+ migration_loader = MigrationLoader(connection)
+ self.assertEqual(migration_loader.migrated_apps, set())
+ self.assertEqual(migration_loader.unmigrated_apps, {"migrated_app"})
+
+ @override_settings(
+ INSTALLED_APPS=["migrations.migrations_test_apps.migrated_app"],
+ MIGRATION_MODULES={"migrated_app": "missing-module"},
+ )
+ def test_explicit_missing_module(self):
+ """
+ If a MIGRATION_MODULES override points to a missing module, the error
+ raised during the importation attempt should be propagated unless
+ `ignore_no_migrations=True`.
+ """
+ with self.assertRaisesMessage(ImportError, "missing-module"):
+ migration_loader = MigrationLoader(connection)
+ migration_loader = MigrationLoader(connection, ignore_no_migrations=True)
+ self.assertEqual(migration_loader.migrated_apps, set())
+ self.assertEqual(migration_loader.unmigrated_apps, {"migrated_app"})
+
+ @override_settings(
+ MIGRATION_MODULES={"migrations": "migrations.test_migrations_squashed"}
+ )
+ def test_loading_squashed(self):
+ "Tests loading a squashed migration"
+ migration_loader = MigrationLoader(connection)
+ recorder = MigrationRecorder(connection)
+ self.addCleanup(recorder.flush)
+ # Loading with nothing applied should just give us the one node
+ self.assertEqual(
+ len([x for x in migration_loader.graph.nodes if x[0] == "migrations"]),
+ 1,
+ )
+ # However, fake-apply one migration and it should now use the old two
+ self.record_applied(recorder, "migrations", "0001_initial")
+ migration_loader.build_graph()
+ self.assertEqual(
+ len([x for x in migration_loader.graph.nodes if x[0] == "migrations"]),
+ 2,
+ )
+
+ @override_settings(
+ MIGRATION_MODULES={"migrations": "migrations.test_migrations_squashed_complex"}
+ )
+ def test_loading_squashed_complex(self):
+ "Tests loading a complex set of squashed migrations"
+
+ loader = MigrationLoader(connection)
+ recorder = MigrationRecorder(connection)
+ self.addCleanup(recorder.flush)
+
+ def num_nodes():
+ plan = set(loader.graph.forwards_plan(("migrations", "7_auto")))
+ return len(plan - loader.applied_migrations.keys())
+
+ # Empty database: use squashed migration
+ loader.build_graph()
+ self.assertEqual(num_nodes(), 5)
+
+ # Starting at 1 or 2 should use the squashed migration too
+ self.record_applied(recorder, "migrations", "1_auto")
+ loader.build_graph()
+ self.assertEqual(num_nodes(), 4)
+
+ self.record_applied(recorder, "migrations", "2_auto")
+ loader.build_graph()
+ self.assertEqual(num_nodes(), 3)
+
+ # However, starting at 3 to 5 cannot use the squashed migration
+ self.record_applied(recorder, "migrations", "3_auto")
+ loader.build_graph()
+ self.assertEqual(num_nodes(), 4)
+
+ self.record_applied(recorder, "migrations", "4_auto")
+ loader.build_graph()
+ self.assertEqual(num_nodes(), 3)
+
+ # Starting at 5 to 7 we are past the squashed migrations.
+ self.record_applied(recorder, "migrations", "5_auto")
+ loader.build_graph()
+ self.assertEqual(num_nodes(), 2)
+
+ self.record_applied(recorder, "migrations", "6_auto")
+ loader.build_graph()
+ self.assertEqual(num_nodes(), 1)
+
+ self.record_applied(recorder, "migrations", "7_auto")
+ loader.build_graph()
+ self.assertEqual(num_nodes(), 0)
+
+ @override_settings(
+ MIGRATION_MODULES={
+ "app1": "migrations.test_migrations_squashed_complex_multi_apps.app1",
+ "app2": "migrations.test_migrations_squashed_complex_multi_apps.app2",
+ }
+ )
+ @modify_settings(
+ INSTALLED_APPS={
+ "append": [
+ "migrations.test_migrations_squashed_complex_multi_apps.app1",
+ "migrations.test_migrations_squashed_complex_multi_apps.app2",
+ ]
+ }
+ )
+ def test_loading_squashed_complex_multi_apps(self):
+ loader = MigrationLoader(connection)
+ loader.build_graph()
+
+ plan = set(loader.graph.forwards_plan(("app1", "4_auto")))
+ expected_plan = {
+ ("app1", "1_auto"),
+ ("app2", "1_squashed_2"),
+ ("app1", "2_squashed_3"),
+ ("app1", "4_auto"),
+ }
+ self.assertEqual(plan, expected_plan)
+
+ @override_settings(
+ MIGRATION_MODULES={
+ "app1": "migrations.test_migrations_squashed_complex_multi_apps.app1",
+ "app2": "migrations.test_migrations_squashed_complex_multi_apps.app2",
+ }
+ )
+ @modify_settings(
+ INSTALLED_APPS={
+ "append": [
+ "migrations.test_migrations_squashed_complex_multi_apps.app1",
+ "migrations.test_migrations_squashed_complex_multi_apps.app2",
+ ]
+ }
+ )
+ def test_loading_squashed_complex_multi_apps_partially_applied(self):
+ loader = MigrationLoader(connection)
+ recorder = MigrationRecorder(connection)
+ self.record_applied(recorder, "app1", "1_auto")
+ self.record_applied(recorder, "app1", "2_auto")
+ loader.build_graph()
+
+ plan = set(loader.graph.forwards_plan(("app1", "4_auto")))
+ plan -= loader.applied_migrations.keys()
+ expected_plan = {
+ ("app2", "1_squashed_2"),
+ ("app1", "3_auto"),
+ ("app1", "4_auto"),
+ }
+
+ self.assertEqual(plan, expected_plan)
+
+ @override_settings(
+ MIGRATION_MODULES={
+ "migrations": "migrations.test_migrations_squashed_erroneous"
+ }
+ )
+ def test_loading_squashed_erroneous(self):
+ "Tests loading a complex but erroneous set of squashed migrations"
+
+ loader = MigrationLoader(connection)
+ recorder = MigrationRecorder(connection)
+ self.addCleanup(recorder.flush)
+
+ def num_nodes():
+ plan = set(loader.graph.forwards_plan(("migrations", "7_auto")))
+ return len(plan - loader.applied_migrations.keys())
+
+ # Empty database: use squashed migration
+ loader.build_graph()
+ self.assertEqual(num_nodes(), 5)
+
+ # Starting at 1 or 2 should use the squashed migration too
+ self.record_applied(recorder, "migrations", "1_auto")
+ loader.build_graph()
+ self.assertEqual(num_nodes(), 4)
+
+ self.record_applied(recorder, "migrations", "2_auto")
+ loader.build_graph()
+ self.assertEqual(num_nodes(), 3)
+
+ # However, starting at 3 or 4, nonexistent migrations would be needed.
+ msg = (
+ "Migration migrations.6_auto depends on nonexistent node "
+ "('migrations', '5_auto'). Django tried to replace migration "
+ "migrations.5_auto with any of [migrations.3_squashed_5] but wasn't able "
+ "to because some of the replaced migrations are already applied."
+ )
+
+ self.record_applied(recorder, "migrations", "3_auto")
+ with self.assertRaisesMessage(NodeNotFoundError, msg):
+ loader.build_graph()
+
+ self.record_applied(recorder, "migrations", "4_auto")
+ with self.assertRaisesMessage(NodeNotFoundError, msg):
+ loader.build_graph()
+
+ # Starting at 5 to 7 we are passed the squashed migrations
+ self.record_applied(recorder, "migrations", "5_auto")
+ loader.build_graph()
+ self.assertEqual(num_nodes(), 2)
+
+ self.record_applied(recorder, "migrations", "6_auto")
+ loader.build_graph()
+ self.assertEqual(num_nodes(), 1)
+
+ self.record_applied(recorder, "migrations", "7_auto")
+ loader.build_graph()
+ self.assertEqual(num_nodes(), 0)
+
+ @override_settings(
+ MIGRATION_MODULES={"migrations": "migrations.test_migrations"},
+ INSTALLED_APPS=["migrations"],
+ )
+ def test_check_consistent_history(self):
+ loader = MigrationLoader(connection=None)
+ loader.check_consistent_history(connection)
+ recorder = MigrationRecorder(connection)
+ self.record_applied(recorder, "migrations", "0002_second")
+ msg = (
+ "Migration migrations.0002_second is applied before its dependency "
+ "migrations.0001_initial on database 'default'."
+ )
+ with self.assertRaisesMessage(InconsistentMigrationHistory, msg):
+ loader.check_consistent_history(connection)
+
+ @override_settings(
+ MIGRATION_MODULES={"migrations": "migrations.test_migrations_squashed_extra"},
+ INSTALLED_APPS=["migrations"],
+ )
+ def test_check_consistent_history_squashed(self):
+ """
+ MigrationLoader.check_consistent_history() should ignore unapplied
+ squashed migrations that have all of their `replaces` applied.
+ """
+ loader = MigrationLoader(connection=None)
+ recorder = MigrationRecorder(connection)
+ self.record_applied(recorder, "migrations", "0001_initial")
+ self.record_applied(recorder, "migrations", "0002_second")
+ loader.check_consistent_history(connection)
+ self.record_applied(recorder, "migrations", "0003_third")
+ loader.check_consistent_history(connection)
+
+ @override_settings(
+ MIGRATION_MODULES={
+ "app1": "migrations.test_migrations_squashed_ref_squashed.app1",
+ "app2": "migrations.test_migrations_squashed_ref_squashed.app2",
+ }
+ )
+ @modify_settings(
+ INSTALLED_APPS={
+ "append": [
+ "migrations.test_migrations_squashed_ref_squashed.app1",
+ "migrations.test_migrations_squashed_ref_squashed.app2",
+ ]
+ }
+ )
+ def test_loading_squashed_ref_squashed(self):
+ "Tests loading a squashed migration with a new migration referencing it"
+ r"""
+ The sample migrations are structured like this:
+
+ app_1 1 --> 2 ---------------------*--> 3 *--> 4
+ \ / /
+ *-------------------*----/--> 2_sq_3 --*
+ \ / /
+ =============== \ ============= / == / ======================
+ app_2 *--> 1_sq_2 --* /
+ \ /
+ *--> 1 --> 2 --*
+
+ Where 2_sq_3 is a replacing migration for 2 and 3 in app_1,
+ as 1_sq_2 is a replacing migration for 1 and 2 in app_2.
+ """
+
+ loader = MigrationLoader(connection)
+ recorder = MigrationRecorder(connection)
+ self.addCleanup(recorder.flush)
+
+ # Load with nothing applied: both migrations squashed.
+ loader.build_graph()
+ plan = set(loader.graph.forwards_plan(("app1", "4_auto")))
+ plan -= loader.applied_migrations.keys()
+ expected_plan = {
+ ("app1", "1_auto"),
+ ("app2", "1_squashed_2"),
+ ("app1", "2_squashed_3"),
+ ("app1", "4_auto"),
+ }
+ self.assertEqual(plan, expected_plan)
+
+ # Load with nothing applied and migrate to a replaced migration.
+ # Not possible if loader.replace_migrations is True (default).
+ loader.build_graph()
+ msg = "Node ('app1', '3_auto') not a valid node"
+ with self.assertRaisesMessage(NodeNotFoundError, msg):
+ loader.graph.forwards_plan(("app1", "3_auto"))
+ # Possible if loader.replace_migrations is False.
+ loader.replace_migrations = False
+ loader.build_graph()
+ plan = set(loader.graph.forwards_plan(("app1", "3_auto")))
+ plan -= loader.applied_migrations.keys()
+ expected_plan = {
+ ("app1", "1_auto"),
+ ("app2", "1_auto"),
+ ("app2", "2_auto"),
+ ("app1", "2_auto"),
+ ("app1", "3_auto"),
+ }
+ self.assertEqual(plan, expected_plan)
+ loader.replace_migrations = True
+
+ # Fake-apply a few from app1: unsquashes migration in app1.
+ self.record_applied(recorder, "app1", "1_auto")
+ self.record_applied(recorder, "app1", "2_auto")
+ loader.build_graph()
+ plan = set(loader.graph.forwards_plan(("app1", "4_auto")))
+ plan -= loader.applied_migrations.keys()
+ expected_plan = {
+ ("app2", "1_squashed_2"),
+ ("app1", "3_auto"),
+ ("app1", "4_auto"),
+ }
+ self.assertEqual(plan, expected_plan)
+
+ # Fake-apply one from app2: unsquashes migration in app2 too.
+ self.record_applied(recorder, "app2", "1_auto")
+ loader.build_graph()
+ plan = set(loader.graph.forwards_plan(("app1", "4_auto")))
+ plan -= loader.applied_migrations.keys()
+ expected_plan = {
+ ("app2", "2_auto"),
+ ("app1", "3_auto"),
+ ("app1", "4_auto"),
+ }
+ self.assertEqual(plan, expected_plan)
+
+ @override_settings(
+ MIGRATION_MODULES={"migrations": "migrations.test_migrations_private"}
+ )
+ def test_ignore_files(self):
+ """Files prefixed with underscore, tilde, or dot aren't loaded."""
+ loader = MigrationLoader(connection)
+ loader.load_disk()
+ migrations = [
+ name for app, name in loader.disk_migrations if app == "migrations"
+ ]
+ self.assertEqual(migrations, ["0001_initial"])
+
+ @override_settings(
+ MIGRATION_MODULES={
+ "migrations": "migrations.test_migrations_namespace_package"
+ },
+ )
+ def test_loading_namespace_package(self):
+ """Migration directories without an __init__.py file are ignored."""
+ loader = MigrationLoader(connection)
+ loader.load_disk()
+ migrations = [
+ name for app, name in loader.disk_migrations if app == "migrations"
+ ]
+ self.assertEqual(migrations, [])
+
+ @override_settings(MIGRATION_MODULES={"migrations": "migrations.test_migrations"})
+ def test_loading_package_without__file__(self):
+ """
+ To support frozen environments, MigrationLoader loads migrations from
+ regular packages with no __file__ attribute.
+ """
+ test_module = import_module("migrations.test_migrations")
+ loader = MigrationLoader(connection)
+ # __file__ == __spec__.origin or the latter is None and former is
+ # undefined.
+ module_file = test_module.__file__
+ module_origin = test_module.__spec__.origin
+ module_has_location = test_module.__spec__.has_location
+ try:
+ del test_module.__file__
+ test_module.__spec__.origin = None
+ test_module.__spec__.has_location = False
+ loader.load_disk()
+ migrations = [
+ name for app, name in loader.disk_migrations if app == "migrations"
+ ]
+ self.assertCountEqual(migrations, ["0001_initial", "0002_second"])
+ finally:
+ test_module.__file__ = module_file
+ test_module.__spec__.origin = module_origin
+ test_module.__spec__.has_location = module_has_location
+
+
+class PycLoaderTests(MigrationTestBase):
+ def test_valid(self):
+ """
+ To support frozen environments, MigrationLoader loads .pyc migrations.
+ """
+ with self.temporary_migration_module(
+ module="migrations.test_migrations"
+ ) as migration_dir:
+ # Compile .py files to .pyc files and delete .py files.
+ compileall.compile_dir(migration_dir, force=True, quiet=1, legacy=True)
+ for name in os.listdir(migration_dir):
+ if name.endswith(".py"):
+ os.remove(os.path.join(migration_dir, name))
+ loader = MigrationLoader(connection)
+ self.assertIn(("migrations", "0001_initial"), loader.disk_migrations)
+
+ def test_invalid(self):
+ """
+ MigrationLoader reraises ImportErrors caused by "bad magic number" pyc
+ files with a more helpful message.
+ """
+ with self.temporary_migration_module(
+ module="migrations.test_migrations_bad_pyc"
+ ) as migration_dir:
+ # The -tpl suffix is to avoid the pyc exclusion in MANIFEST.in.
+ os.rename(
+ os.path.join(migration_dir, "0001_initial.pyc-tpl"),
+ os.path.join(migration_dir, "0001_initial.pyc"),
+ )
+ msg = (
+ r"Couldn't import '\w+.migrations.0001_initial' as it appears "
+ "to be a stale .pyc file."
+ )
+ with self.assertRaisesRegex(ImportError, msg):
+ MigrationLoader(connection)
diff --git a/testbed/django__django/tests/migrations/test_migrations/0001_initial.py b/testbed/django__django/tests/migrations/test_migrations/0001_initial.py
new file mode 100644
index 0000000000000000000000000000000000000000..20ca1391f6fe98721c1712047974fd24e06c380a
--- /dev/null
+++ b/testbed/django__django/tests/migrations/test_migrations/0001_initial.py
@@ -0,0 +1,34 @@
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+ initial = True
+
+ operations = [
+ migrations.CreateModel(
+ "Author",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ("name", models.CharField(max_length=255)),
+ ("slug", models.SlugField(null=True)),
+ ("age", models.IntegerField(default=0)),
+ ("silly_field", models.BooleanField(default=False)),
+ ],
+ ),
+ migrations.CreateModel(
+ "Tribble",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ("fluffy", models.BooleanField(default=True)),
+ ],
+ ),
+ migrations.AddField(
+ model_name="tribble",
+ name="bool",
+ field=models.BooleanField(default=False),
+ ),
+ migrations.AlterUniqueTogether(
+ name="author",
+ unique_together={("name", "slug")},
+ ),
+ ]
diff --git a/testbed/django__django/tests/migrations/test_migrations/0002_second.py b/testbed/django__django/tests/migrations/test_migrations/0002_second.py
new file mode 100644
index 0000000000000000000000000000000000000000..059b7ba2e77b67bb4920dd49e1bd20151f411054
--- /dev/null
+++ b/testbed/django__django/tests/migrations/test_migrations/0002_second.py
@@ -0,0 +1,23 @@
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+ dependencies = [
+ ("migrations", "0001_initial"),
+ ]
+
+ operations = [
+ migrations.DeleteModel("Tribble"),
+ migrations.RemoveField("Author", "silly_field"),
+ migrations.AddField("Author", "rating", models.IntegerField(default=0)),
+ migrations.CreateModel(
+ "Book",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ (
+ "author",
+ models.ForeignKey("migrations.Author", models.SET_NULL, null=True),
+ ),
+ ],
+ ),
+ ]
diff --git a/testbed/django__django/tests/migrations/test_migrations/__init__.py b/testbed/django__django/tests/migrations/test_migrations/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testbed/django__django/tests/migrations/test_migrations_atomic_operation/0001_initial.py b/testbed/django__django/tests/migrations/test_migrations_atomic_operation/0001_initial.py
new file mode 100644
index 0000000000000000000000000000000000000000..b3c05c774d1a950ccbd81968f2c8902f469e6d90
--- /dev/null
+++ b/testbed/django__django/tests/migrations/test_migrations_atomic_operation/0001_initial.py
@@ -0,0 +1,22 @@
+from django.db import migrations, models
+
+
+def raise_error(apps, schema_editor):
+ # Test atomic operation in non-atomic migration is wrapped in transaction
+ Editor = apps.get_model("migrations", "Editor")
+ Editor.objects.create(name="Test Editor")
+ raise RuntimeError("Abort migration")
+
+
+class Migration(migrations.Migration):
+ atomic = False
+
+ operations = [
+ migrations.CreateModel(
+ "Editor",
+ [
+ ("name", models.CharField(primary_key=True, max_length=255)),
+ ],
+ ),
+ migrations.RunPython(raise_error, reverse_code=raise_error, atomic=True),
+ ]
diff --git a/testbed/django__django/tests/migrations/test_migrations_atomic_operation/__init__.py b/testbed/django__django/tests/migrations/test_migrations_atomic_operation/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testbed/django__django/tests/migrations/test_migrations_backwards_deps_1/0001_initial.py b/testbed/django__django/tests/migrations/test_migrations_backwards_deps_1/0001_initial.py
new file mode 100644
index 0000000000000000000000000000000000000000..de3ea271734fc932a81497d823eff164f4d4f178
--- /dev/null
+++ b/testbed/django__django/tests/migrations/test_migrations_backwards_deps_1/0001_initial.py
@@ -0,0 +1,5 @@
+from django.db import migrations
+
+
+class Migration(migrations.Migration):
+ operations = []
diff --git a/testbed/django__django/tests/migrations/test_migrations_backwards_deps_1/0002_second.py b/testbed/django__django/tests/migrations/test_migrations_backwards_deps_1/0002_second.py
new file mode 100644
index 0000000000000000000000000000000000000000..324f3d1b4cf39518bc67d00bc15969aa82eddf6b
--- /dev/null
+++ b/testbed/django__django/tests/migrations/test_migrations_backwards_deps_1/0002_second.py
@@ -0,0 +1,6 @@
+from django.db import migrations
+
+
+class Migration(migrations.Migration):
+ dependencies = [("migrations", "0001_initial")]
+ operations = []
diff --git a/testbed/django__django/tests/migrations/test_migrations_bad_pyc/0001_initial.pyc-tpl b/testbed/django__django/tests/migrations/test_migrations_bad_pyc/0001_initial.pyc-tpl
new file mode 100644
index 0000000000000000000000000000000000000000..07854f4aebed369ef4a294ad00cab1b2d4f32f61
Binary files /dev/null and b/testbed/django__django/tests/migrations/test_migrations_bad_pyc/0001_initial.pyc-tpl differ
diff --git a/testbed/django__django/tests/migrations/test_migrations_bad_pyc/__init__.py b/testbed/django__django/tests/migrations/test_migrations_bad_pyc/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testbed/django__django/tests/migrations/test_migrations_clashing_prefix/__init__.py b/testbed/django__django/tests/migrations/test_migrations_clashing_prefix/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testbed/django__django/tests/migrations/test_migrations_clashing_prefix/a.py b/testbed/django__django/tests/migrations/test_migrations_clashing_prefix/a.py
new file mode 100644
index 0000000000000000000000000000000000000000..bd613aa95e0e71fa0ab0fc899baebf5e399b13ae
--- /dev/null
+++ b/testbed/django__django/tests/migrations/test_migrations_clashing_prefix/a.py
@@ -0,0 +1,5 @@
+from django.db import migrations
+
+
+class Migration(migrations.Migration):
+ pass
diff --git a/testbed/django__django/tests/migrations/test_migrations_clashing_prefix/ab.py b/testbed/django__django/tests/migrations/test_migrations_clashing_prefix/ab.py
new file mode 100644
index 0000000000000000000000000000000000000000..539e347b0c62d411578dd48ab77afb0ca8c4b53a
--- /dev/null
+++ b/testbed/django__django/tests/migrations/test_migrations_clashing_prefix/ab.py
@@ -0,0 +1,5 @@
+from django.db import migrations
+
+
+class Migration(migrations.Migration):
+ dependencies = [("migrations", "a")]
diff --git a/testbed/django__django/tests/migrations/test_migrations_conflict/0001_initial.py b/testbed/django__django/tests/migrations/test_migrations_conflict/0001_initial.py
new file mode 100644
index 0000000000000000000000000000000000000000..42aadab7a003546192cdd83e28fa7e12b9eb4a38
--- /dev/null
+++ b/testbed/django__django/tests/migrations/test_migrations_conflict/0001_initial.py
@@ -0,0 +1,23 @@
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+ operations = [
+ migrations.CreateModel(
+ "Author",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ("name", models.CharField(max_length=255)),
+ ("slug", models.SlugField(null=True)),
+ ("age", models.IntegerField(default=0)),
+ ("silly_field", models.BooleanField(default=False)),
+ ],
+ ),
+ migrations.CreateModel(
+ "Tribble",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ("fluffy", models.BooleanField(default=True)),
+ ],
+ ),
+ ]
diff --git a/testbed/django__django/tests/migrations/test_migrations_conflict/0002_conflicting_second.py b/testbed/django__django/tests/migrations/test_migrations_conflict/0002_conflicting_second.py
new file mode 100644
index 0000000000000000000000000000000000000000..8b73eb7714977bae9cdd09d130853adc504d171b
--- /dev/null
+++ b/testbed/django__django/tests/migrations/test_migrations_conflict/0002_conflicting_second.py
@@ -0,0 +1,14 @@
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+ dependencies = [("migrations", "0001_initial")]
+
+ operations = [
+ migrations.CreateModel(
+ "Something",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ],
+ )
+ ]
diff --git a/testbed/django__django/tests/migrations/test_migrations_conflict/0002_second.py b/testbed/django__django/tests/migrations/test_migrations_conflict/0002_second.py
new file mode 100644
index 0000000000000000000000000000000000000000..55d3b9aaad88c8bab80ac803186ff4ac93cd1d3b
--- /dev/null
+++ b/testbed/django__django/tests/migrations/test_migrations_conflict/0002_second.py
@@ -0,0 +1,21 @@
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+ dependencies = [("migrations", "0001_initial")]
+
+ operations = [
+ migrations.DeleteModel("Tribble"),
+ migrations.RemoveField("Author", "silly_field"),
+ migrations.AddField("Author", "rating", models.IntegerField(default=0)),
+ migrations.CreateModel(
+ "Book",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ (
+ "author",
+ models.ForeignKey("migrations.Author", models.SET_NULL, null=True),
+ ),
+ ],
+ ),
+ ]
diff --git a/testbed/django__django/tests/migrations/test_migrations_conflict/__init__.py b/testbed/django__django/tests/migrations/test_migrations_conflict/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testbed/django__django/tests/migrations/test_migrations_conflict_long_name/0001_initial.py b/testbed/django__django/tests/migrations/test_migrations_conflict_long_name/0001_initial.py
new file mode 100644
index 0000000000000000000000000000000000000000..8adce29cbdd7ccd5dfdcb9a53c0138c8c1c2bd91
--- /dev/null
+++ b/testbed/django__django/tests/migrations/test_migrations_conflict_long_name/0001_initial.py
@@ -0,0 +1,14 @@
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+ initial = True
+
+ operations = [
+ migrations.CreateModel(
+ "Author",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ],
+ ),
+ ]
diff --git a/testbed/django__django/tests/migrations/test_migrations_conflict_long_name/0002_conflicting_second_migration_with_long_name.py b/testbed/django__django/tests/migrations/test_migrations_conflict_long_name/0002_conflicting_second_migration_with_long_name.py
new file mode 100644
index 0000000000000000000000000000000000000000..ddac8d8fe56ebb6aaab6a45488606734f4ab74f2
--- /dev/null
+++ b/testbed/django__django/tests/migrations/test_migrations_conflict_long_name/0002_conflicting_second_migration_with_long_name.py
@@ -0,0 +1,14 @@
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+ dependencies = [("migrations", "0001_initial")]
+
+ operations = [
+ migrations.CreateModel(
+ "SomethingElse",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ],
+ ),
+ ]
diff --git a/testbed/django__django/tests/migrations/test_migrations_conflict_long_name/0002_second.py b/testbed/django__django/tests/migrations/test_migrations_conflict_long_name/0002_second.py
new file mode 100644
index 0000000000000000000000000000000000000000..cc355d3bc09a3da88b2c6bced7e5f01e3baa1445
--- /dev/null
+++ b/testbed/django__django/tests/migrations/test_migrations_conflict_long_name/0002_second.py
@@ -0,0 +1,14 @@
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+ dependencies = [("migrations", "0001_initial")]
+
+ operations = [
+ migrations.CreateModel(
+ "Something",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ],
+ ),
+ ]
diff --git a/testbed/django__django/tests/migrations/test_migrations_conflict_long_name/__init__.py b/testbed/django__django/tests/migrations/test_migrations_conflict_long_name/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testbed/django__django/tests/migrations/test_migrations_custom_user/0001_initial.py b/testbed/django__django/tests/migrations/test_migrations_custom_user/0001_initial.py
new file mode 100644
index 0000000000000000000000000000000000000000..e562436df757382cc6cab3535507fee808f10966
--- /dev/null
+++ b/testbed/django__django/tests/migrations/test_migrations_custom_user/0001_initial.py
@@ -0,0 +1,30 @@
+from django.conf import settings
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+ dependencies = [
+ migrations.swappable_dependency(settings.AUTH_USER_MODEL),
+ ]
+
+ operations = [
+ migrations.CreateModel(
+ "Author",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ("name", models.CharField(max_length=255)),
+ ],
+ ),
+ migrations.CreateModel(
+ "Tribble",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ (
+ "author",
+ models.ForeignKey(
+ settings.AUTH_USER_MODEL, models.CASCADE, to_field="id"
+ ),
+ ),
+ ],
+ ),
+ ]
diff --git a/testbed/django__django/tests/migrations/test_migrations_custom_user/__init__.py b/testbed/django__django/tests/migrations/test_migrations_custom_user/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testbed/django__django/tests/migrations/test_migrations_empty/__init__.py b/testbed/django__django/tests/migrations/test_migrations_empty/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testbed/django__django/tests/migrations/test_migrations_fake_split_initial/0001_initial.py b/testbed/django__django/tests/migrations/test_migrations_fake_split_initial/0001_initial.py
new file mode 100644
index 0000000000000000000000000000000000000000..99bf99b6157110c2efe084692245228d4f326254
--- /dev/null
+++ b/testbed/django__django/tests/migrations/test_migrations_fake_split_initial/0001_initial.py
@@ -0,0 +1,29 @@
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+ initial = True
+
+ operations = [
+ migrations.CreateModel(
+ "Author",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ("name", models.CharField(max_length=255)),
+ ("slug", models.SlugField(null=True)),
+ ("age", models.IntegerField(default=0)),
+ ("silly_field", models.BooleanField(default=False)),
+ ],
+ ),
+ migrations.CreateModel(
+ "Tribble",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ("fluffy", models.BooleanField(default=True)),
+ ],
+ ),
+ migrations.AlterUniqueTogether(
+ name="author",
+ unique_together={("name", "slug")},
+ ),
+ ]
diff --git a/testbed/django__django/tests/migrations/test_migrations_fake_split_initial/0002_second.py b/testbed/django__django/tests/migrations/test_migrations_fake_split_initial/0002_second.py
new file mode 100644
index 0000000000000000000000000000000000000000..e9ad8b2b03ba20908d9d8032f53ae6a10c6b4b3c
--- /dev/null
+++ b/testbed/django__django/tests/migrations/test_migrations_fake_split_initial/0002_second.py
@@ -0,0 +1,23 @@
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+ initial = True
+
+ dependencies = [
+ ("migrations", "0001_initial"),
+ ]
+
+ operations = [
+ migrations.AddField("Author", "rating", models.IntegerField(default=0)),
+ migrations.CreateModel(
+ "Book",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ (
+ "author",
+ models.ForeignKey("migrations.Author", models.SET_NULL, null=True),
+ ),
+ ],
+ ),
+ ]
diff --git a/testbed/django__django/tests/migrations/test_migrations_fake_split_initial/__init__.py b/testbed/django__django/tests/migrations/test_migrations_fake_split_initial/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testbed/django__django/tests/migrations/test_migrations_first/__init__.py b/testbed/django__django/tests/migrations/test_migrations_first/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testbed/django__django/tests/migrations/test_migrations_first/second.py b/testbed/django__django/tests/migrations/test_migrations_first/second.py
new file mode 100644
index 0000000000000000000000000000000000000000..3a02a8b8678bd773634f6c40ed7b7c608c8f1560
--- /dev/null
+++ b/testbed/django__django/tests/migrations/test_migrations_first/second.py
@@ -0,0 +1,24 @@
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+ dependencies = [
+ ("migrations", "thefirst"),
+ ("migrations2", "0002_second"),
+ ]
+
+ operations = [
+ migrations.DeleteModel("Tribble"),
+ migrations.RemoveField("Author", "silly_field"),
+ migrations.AddField("Author", "rating", models.IntegerField(default=0)),
+ migrations.CreateModel(
+ "Book",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ (
+ "author",
+ models.ForeignKey("migrations.Author", models.SET_NULL, null=True),
+ ),
+ ],
+ ),
+ ]
diff --git a/testbed/django__django/tests/migrations/test_migrations_first/thefirst.py b/testbed/django__django/tests/migrations/test_migrations_first/thefirst.py
new file mode 100644
index 0000000000000000000000000000000000000000..42aadab7a003546192cdd83e28fa7e12b9eb4a38
--- /dev/null
+++ b/testbed/django__django/tests/migrations/test_migrations_first/thefirst.py
@@ -0,0 +1,23 @@
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+ operations = [
+ migrations.CreateModel(
+ "Author",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ("name", models.CharField(max_length=255)),
+ ("slug", models.SlugField(null=True)),
+ ("age", models.IntegerField(default=0)),
+ ("silly_field", models.BooleanField(default=False)),
+ ],
+ ),
+ migrations.CreateModel(
+ "Tribble",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ("fluffy", models.BooleanField(default=True)),
+ ],
+ ),
+ ]
diff --git a/testbed/django__django/tests/migrations/test_migrations_initial_false/0001_not_initial.py b/testbed/django__django/tests/migrations/test_migrations_initial_false/0001_not_initial.py
new file mode 100644
index 0000000000000000000000000000000000000000..d358944e8c6c1445d618cd55bbefdc6eb41875c5
--- /dev/null
+++ b/testbed/django__django/tests/migrations/test_migrations_initial_false/0001_not_initial.py
@@ -0,0 +1,29 @@
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+ initial = False
+
+ operations = [
+ migrations.CreateModel(
+ "Author",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ("name", models.CharField(max_length=255)),
+ ("slug", models.SlugField(null=True)),
+ ("age", models.IntegerField(default=0)),
+ ("silly_field", models.BooleanField(default=False)),
+ ],
+ ),
+ migrations.CreateModel(
+ "Tribble",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ("fluffy", models.BooleanField(default=True)),
+ ],
+ ),
+ migrations.AlterUniqueTogether(
+ name="author",
+ unique_together={("name", "slug")},
+ ),
+ ]
diff --git a/testbed/django__django/tests/migrations/test_migrations_initial_false/__init__.py b/testbed/django__django/tests/migrations/test_migrations_initial_false/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testbed/django__django/tests/migrations/test_migrations_manual_porting/0001_initial.py b/testbed/django__django/tests/migrations/test_migrations_manual_porting/0001_initial.py
new file mode 100644
index 0000000000000000000000000000000000000000..8f827dcdca95be87c600ce7496de6e24e35543a9
--- /dev/null
+++ b/testbed/django__django/tests/migrations/test_migrations_manual_porting/0001_initial.py
@@ -0,0 +1,15 @@
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+ initial = True
+
+ operations = [
+ migrations.CreateModel(
+ "SomeModel",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ("name", models.CharField(max_length=255)),
+ ],
+ ),
+ ]
diff --git a/testbed/django__django/tests/migrations/test_migrations_manual_porting/0002_second.py b/testbed/django__django/tests/migrations/test_migrations_manual_porting/0002_second.py
new file mode 100644
index 0000000000000000000000000000000000000000..b83c13f84d877972c477f08fd6c303119b991a60
--- /dev/null
+++ b/testbed/django__django/tests/migrations/test_migrations_manual_porting/0002_second.py
@@ -0,0 +1,15 @@
+from django.db import migrations
+
+
+def forwards(apps, schema_editor):
+ pass
+
+
+class Migration(migrations.Migration):
+ dependencies = [
+ ("migrations", "0001_initial"),
+ ]
+
+ operations = [
+ migrations.RunPython(forwards, migrations.RunPython.noop),
+ ]
diff --git a/testbed/django__django/tests/migrations/test_migrations_manual_porting/0003_third.py b/testbed/django__django/tests/migrations/test_migrations_manual_porting/0003_third.py
new file mode 100644
index 0000000000000000000000000000000000000000..fefd2733d952fea6bb717da85db4da95b7dec33d
--- /dev/null
+++ b/testbed/django__django/tests/migrations/test_migrations_manual_porting/0003_third.py
@@ -0,0 +1,23 @@
+from django.db import migrations
+
+
+def forwards(apps, schema_editor):
+ pass
+
+
+class Migration(migrations.Migration):
+ dependencies = [
+ ("migrations", "0002_second"),
+ ]
+
+ operations = [
+ migrations.AlterUniqueTogether(
+ name="somemodel",
+ unique_together={("id", "name")},
+ ),
+ migrations.AlterUniqueTogether(
+ name="somemodel",
+ unique_together={("name",)},
+ ),
+ migrations.RunPython(forwards, migrations.RunPython.noop),
+ ]
diff --git a/testbed/django__django/tests/migrations/test_migrations_manual_porting/0004_fourth.py b/testbed/django__django/tests/migrations/test_migrations_manual_porting/0004_fourth.py
new file mode 100644
index 0000000000000000000000000000000000000000..0384334e687fba02efa7f894854ef0e4b3878985
--- /dev/null
+++ b/testbed/django__django/tests/migrations/test_migrations_manual_porting/0004_fourth.py
@@ -0,0 +1,27 @@
+from django.db import migrations
+
+
+def forwards(apps, schema_editor):
+ pass
+
+
+class Migration(migrations.Migration):
+ dependencies = [
+ ("migrations", "0002_second"),
+ ]
+
+ replaces = [
+ ("migrations", "0003_third"),
+ ]
+
+ operations = [
+ migrations.AlterUniqueTogether(
+ name="somemodel",
+ unique_together={("id", "name")},
+ ),
+ migrations.AlterUniqueTogether(
+ name="somemodel",
+ unique_together={("name",)},
+ ),
+ migrations.RunPython(forwards, migrations.RunPython.noop),
+ ]
diff --git a/testbed/django__django/tests/migrations/test_migrations_manual_porting/__init__.py b/testbed/django__django/tests/migrations/test_migrations_manual_porting/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testbed/django__django/tests/migrations/test_migrations_namespace_package/0001_initial.py b/testbed/django__django/tests/migrations/test_migrations_namespace_package/0001_initial.py
new file mode 100644
index 0000000000000000000000000000000000000000..34c73ea086225f8f9ed15310f783ea01557049d7
--- /dev/null
+++ b/testbed/django__django/tests/migrations/test_migrations_namespace_package/0001_initial.py
@@ -0,0 +1,15 @@
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+ initial = True
+
+ operations = [
+ migrations.CreateModel(
+ "Author",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ("name", models.CharField(max_length=255)),
+ ],
+ ),
+ ]
diff --git a/testbed/django__django/tests/migrations/test_migrations_no_ancestor/0001_initial.py b/testbed/django__django/tests/migrations/test_migrations_no_ancestor/0001_initial.py
new file mode 100644
index 0000000000000000000000000000000000000000..42aadab7a003546192cdd83e28fa7e12b9eb4a38
--- /dev/null
+++ b/testbed/django__django/tests/migrations/test_migrations_no_ancestor/0001_initial.py
@@ -0,0 +1,23 @@
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+ operations = [
+ migrations.CreateModel(
+ "Author",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ("name", models.CharField(max_length=255)),
+ ("slug", models.SlugField(null=True)),
+ ("age", models.IntegerField(default=0)),
+ ("silly_field", models.BooleanField(default=False)),
+ ],
+ ),
+ migrations.CreateModel(
+ "Tribble",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ("fluffy", models.BooleanField(default=True)),
+ ],
+ ),
+ ]
diff --git a/testbed/django__django/tests/migrations/test_migrations_no_ancestor/0002_conflicting_second.py b/testbed/django__django/tests/migrations/test_migrations_no_ancestor/0002_conflicting_second.py
new file mode 100644
index 0000000000000000000000000000000000000000..2765b16f854d13e45670a8609ee9832319c1efab
--- /dev/null
+++ b/testbed/django__django/tests/migrations/test_migrations_no_ancestor/0002_conflicting_second.py
@@ -0,0 +1,21 @@
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+ dependencies = []
+
+ operations = [
+ migrations.DeleteModel("Tribble"),
+ migrations.RemoveField("Author", "silly_field"),
+ migrations.AddField("Author", "rating", models.IntegerField(default=0)),
+ migrations.CreateModel(
+ "Book",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ (
+ "author",
+ models.ForeignKey("migrations.Author", models.SET_NULL, null=True),
+ ),
+ ],
+ ),
+ ]
diff --git a/testbed/django__django/tests/migrations/test_migrations_no_ancestor/0002_second.py b/testbed/django__django/tests/migrations/test_migrations_no_ancestor/0002_second.py
new file mode 100644
index 0000000000000000000000000000000000000000..059b7ba2e77b67bb4920dd49e1bd20151f411054
--- /dev/null
+++ b/testbed/django__django/tests/migrations/test_migrations_no_ancestor/0002_second.py
@@ -0,0 +1,23 @@
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+ dependencies = [
+ ("migrations", "0001_initial"),
+ ]
+
+ operations = [
+ migrations.DeleteModel("Tribble"),
+ migrations.RemoveField("Author", "silly_field"),
+ migrations.AddField("Author", "rating", models.IntegerField(default=0)),
+ migrations.CreateModel(
+ "Book",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ (
+ "author",
+ models.ForeignKey("migrations.Author", models.SET_NULL, null=True),
+ ),
+ ],
+ ),
+ ]
diff --git a/testbed/django__django/tests/migrations/test_migrations_no_ancestor/__init__.py b/testbed/django__django/tests/migrations/test_migrations_no_ancestor/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testbed/django__django/tests/migrations/test_migrations_no_changes/0001_initial.py b/testbed/django__django/tests/migrations/test_migrations_no_changes/0001_initial.py
new file mode 100644
index 0000000000000000000000000000000000000000..42aadab7a003546192cdd83e28fa7e12b9eb4a38
--- /dev/null
+++ b/testbed/django__django/tests/migrations/test_migrations_no_changes/0001_initial.py
@@ -0,0 +1,23 @@
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+ operations = [
+ migrations.CreateModel(
+ "Author",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ("name", models.CharField(max_length=255)),
+ ("slug", models.SlugField(null=True)),
+ ("age", models.IntegerField(default=0)),
+ ("silly_field", models.BooleanField(default=False)),
+ ],
+ ),
+ migrations.CreateModel(
+ "Tribble",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ("fluffy", models.BooleanField(default=True)),
+ ],
+ ),
+ ]
diff --git a/testbed/django__django/tests/migrations/test_migrations_no_changes/0002_second.py b/testbed/django__django/tests/migrations/test_migrations_no_changes/0002_second.py
new file mode 100644
index 0000000000000000000000000000000000000000..059b7ba2e77b67bb4920dd49e1bd20151f411054
--- /dev/null
+++ b/testbed/django__django/tests/migrations/test_migrations_no_changes/0002_second.py
@@ -0,0 +1,23 @@
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+ dependencies = [
+ ("migrations", "0001_initial"),
+ ]
+
+ operations = [
+ migrations.DeleteModel("Tribble"),
+ migrations.RemoveField("Author", "silly_field"),
+ migrations.AddField("Author", "rating", models.IntegerField(default=0)),
+ migrations.CreateModel(
+ "Book",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ (
+ "author",
+ models.ForeignKey("migrations.Author", models.SET_NULL, null=True),
+ ),
+ ],
+ ),
+ ]
diff --git a/testbed/django__django/tests/migrations/test_migrations_no_changes/0003_third.py b/testbed/django__django/tests/migrations/test_migrations_no_changes/0003_third.py
new file mode 100644
index 0000000000000000000000000000000000000000..e810902a401bed386466d5305c0197065d894119
--- /dev/null
+++ b/testbed/django__django/tests/migrations/test_migrations_no_changes/0003_third.py
@@ -0,0 +1,48 @@
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+ dependencies = [
+ ("migrations", "0002_second"),
+ ]
+
+ operations = [
+ migrations.CreateModel(
+ name="ModelWithCustomBase",
+ fields=[
+ (
+ "id",
+ models.AutoField(
+ verbose_name="ID",
+ serialize=False,
+ auto_created=True,
+ primary_key=True,
+ ),
+ ),
+ ],
+ options={},
+ bases=(models.Model,),
+ ),
+ migrations.CreateModel(
+ name="UnmigratedModel",
+ fields=[
+ (
+ "id",
+ models.AutoField(
+ verbose_name="ID",
+ serialize=False,
+ auto_created=True,
+ primary_key=True,
+ ),
+ ),
+ ],
+ options={},
+ bases=(models.Model,),
+ ),
+ migrations.DeleteModel(
+ name="Author",
+ ),
+ migrations.DeleteModel(
+ name="Book",
+ ),
+ ]
diff --git a/testbed/django__django/tests/migrations/test_migrations_no_changes/__init__.py b/testbed/django__django/tests/migrations/test_migrations_no_changes/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testbed/django__django/tests/migrations/test_migrations_no_default/0001_initial.py b/testbed/django__django/tests/migrations/test_migrations_no_default/0001_initial.py
new file mode 100644
index 0000000000000000000000000000000000000000..5be2a9268e2b49fe11ecdef198411c9314025c79
--- /dev/null
+++ b/testbed/django__django/tests/migrations/test_migrations_no_default/0001_initial.py
@@ -0,0 +1,25 @@
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+ dependencies = []
+
+ operations = [
+ migrations.CreateModel(
+ name="SillyModel",
+ fields=[
+ (
+ "id",
+ models.AutoField(
+ verbose_name="ID",
+ serialize=False,
+ auto_created=True,
+ primary_key=True,
+ ),
+ ),
+ ("silly_field", models.BooleanField(default=False)),
+ ],
+ options={},
+ bases=(models.Model,),
+ ),
+ ]
diff --git a/testbed/django__django/tests/migrations/test_migrations_no_default/__init__.py b/testbed/django__django/tests/migrations/test_migrations_no_default/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testbed/django__django/tests/migrations/test_migrations_no_init/.gitkeep b/testbed/django__django/tests/migrations/test_migrations_no_init/.gitkeep
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testbed/django__django/tests/migrations/test_migrations_no_operations/0001_initial.py b/testbed/django__django/tests/migrations/test_migrations_no_operations/0001_initial.py
new file mode 100644
index 0000000000000000000000000000000000000000..a07dd888da3ef86f2fa1d883322cf25c365e15e8
--- /dev/null
+++ b/testbed/django__django/tests/migrations/test_migrations_no_operations/0001_initial.py
@@ -0,0 +1,6 @@
+from django.db import migrations
+
+
+class Migration(migrations.Migration):
+ dependencies = []
+ operations = []
diff --git a/testbed/django__django/tests/migrations/test_migrations_no_operations/__init__.py b/testbed/django__django/tests/migrations/test_migrations_no_operations/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testbed/django__django/tests/migrations/test_migrations_non_atomic/0001_initial.py b/testbed/django__django/tests/migrations/test_migrations_non_atomic/0001_initial.py
new file mode 100644
index 0000000000000000000000000000000000000000..c8379e8e072d222ff9491abccb76b403ea722e9e
--- /dev/null
+++ b/testbed/django__django/tests/migrations/test_migrations_non_atomic/0001_initial.py
@@ -0,0 +1,34 @@
+from django.db import migrations, models
+
+
+def raise_error(apps, schema_editor):
+ # Test operation in non-atomic migration is not wrapped in transaction
+ Publisher = apps.get_model("migrations", "Publisher")
+ Publisher.objects.create(name="Test Publisher")
+ raise RuntimeError("Abort migration")
+
+
+class Migration(migrations.Migration):
+ atomic = False
+
+ operations = [
+ migrations.CreateModel(
+ "Publisher",
+ [
+ ("name", models.CharField(primary_key=True, max_length=255)),
+ ],
+ ),
+ migrations.RunPython(raise_error),
+ migrations.CreateModel(
+ "Book",
+ [
+ ("title", models.CharField(primary_key=True, max_length=255)),
+ (
+ "publisher",
+ models.ForeignKey(
+ "migrations.Publisher", models.SET_NULL, null=True
+ ),
+ ),
+ ],
+ ),
+ ]
diff --git a/testbed/django__django/tests/migrations/test_migrations_non_atomic/__init__.py b/testbed/django__django/tests/migrations/test_migrations_non_atomic/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testbed/django__django/tests/migrations/test_migrations_noop/0001_initial.py b/testbed/django__django/tests/migrations/test_migrations_noop/0001_initial.py
new file mode 100644
index 0000000000000000000000000000000000000000..b74b561c252bfb7135780777638172871cbf3b3f
--- /dev/null
+++ b/testbed/django__django/tests/migrations/test_migrations_noop/0001_initial.py
@@ -0,0 +1,9 @@
+from django.db import migrations
+
+
+class Migration(migrations.Migration):
+ initial = True
+
+ operations = [
+ migrations.RunSQL(sql="", reverse_sql=""),
+ ]
diff --git a/testbed/django__django/tests/migrations/test_migrations_noop/__init__.py b/testbed/django__django/tests/migrations/test_migrations_noop/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testbed/django__django/tests/migrations/test_migrations_order/0001.py b/testbed/django__django/tests/migrations/test_migrations_order/0001.py
new file mode 100644
index 0000000000000000000000000000000000000000..94447f8339185caba8b45d735365d1a17ae9de7f
--- /dev/null
+++ b/testbed/django__django/tests/migrations/test_migrations_order/0001.py
@@ -0,0 +1,7 @@
+from django.db import migrations
+
+
+class Migration(migrations.Migration):
+ initial = True
+
+ operations = []
diff --git a/testbed/django__django/tests/migrations/test_migrations_order/__init__.py b/testbed/django__django/tests/migrations/test_migrations_order/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testbed/django__django/tests/migrations/test_migrations_plan/0001_initial.py b/testbed/django__django/tests/migrations/test_migrations_plan/0001_initial.py
new file mode 100644
index 0000000000000000000000000000000000000000..9f60a2efd73998dd44bf6ca972033bce7cd704c4
--- /dev/null
+++ b/testbed/django__django/tests/migrations/test_migrations_plan/0001_initial.py
@@ -0,0 +1,27 @@
+from django.db import migrations, models
+
+
+def grow_tail(x, y):
+ """Grow salamander tail."""
+ pass
+
+
+def shrink_tail(x, y):
+ """Shrink salamander tail."""
+ pass
+
+
+class Migration(migrations.Migration):
+ initial = True
+
+ operations = [
+ migrations.CreateModel(
+ "Salamander",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ("tail", models.IntegerField(default=0)),
+ ("silly_field", models.BooleanField(default=False)),
+ ],
+ ),
+ migrations.RunPython(grow_tail, shrink_tail),
+ ]
diff --git a/testbed/django__django/tests/migrations/test_migrations_plan/0002_second.py b/testbed/django__django/tests/migrations/test_migrations_plan/0002_second.py
new file mode 100644
index 0000000000000000000000000000000000000000..a0b8af671080c963450a943f572cf0188d8e52dd
--- /dev/null
+++ b/testbed/django__django/tests/migrations/test_migrations_plan/0002_second.py
@@ -0,0 +1,19 @@
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+ dependencies = [
+ ("migrations", "0001_initial"),
+ ]
+
+ operations = [
+ migrations.CreateModel(
+ "Book",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ],
+ ),
+ migrations.RunSQL(
+ ["SELECT * FROM migrations_book"], ["SELECT * FROM migrations_salamander"]
+ ),
+ ]
diff --git a/testbed/django__django/tests/migrations/test_migrations_plan/0003_third.py b/testbed/django__django/tests/migrations/test_migrations_plan/0003_third.py
new file mode 100644
index 0000000000000000000000000000000000000000..7a5e341798923a39d8b6b456dac245e1c489ee38
--- /dev/null
+++ b/testbed/django__django/tests/migrations/test_migrations_plan/0003_third.py
@@ -0,0 +1,19 @@
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+ dependencies = [
+ ("migrations", "0002_second"),
+ ]
+
+ operations = [
+ migrations.CreateModel(
+ "Author",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ],
+ ),
+ migrations.RunSQL(
+ ["SELECT * FROM migrations_author"], ["SELECT * FROM migrations_book"]
+ ),
+ ]
diff --git a/testbed/django__django/tests/migrations/test_migrations_plan/0004_fourth.py b/testbed/django__django/tests/migrations/test_migrations_plan/0004_fourth.py
new file mode 100644
index 0000000000000000000000000000000000000000..885d26a7d1ec699b5f365f1ea122e38698efd4e6
--- /dev/null
+++ b/testbed/django__django/tests/migrations/test_migrations_plan/0004_fourth.py
@@ -0,0 +1,9 @@
+from django.db import migrations
+
+
+class Migration(migrations.Migration):
+ dependencies = [
+ ("migrations", "0003_third"),
+ ]
+
+ operations = [migrations.RunSQL("SELECT * FROM migrations_author WHERE id = 1")]
diff --git a/testbed/django__django/tests/migrations/test_migrations_plan/0005_fifth.py b/testbed/django__django/tests/migrations/test_migrations_plan/0005_fifth.py
new file mode 100644
index 0000000000000000000000000000000000000000..0fe4a29cdbe83e92158108fce10abd4ad7c92356
--- /dev/null
+++ b/testbed/django__django/tests/migrations/test_migrations_plan/0005_fifth.py
@@ -0,0 +1,22 @@
+from django.db import migrations
+
+
+def grow_tail(x, y):
+ pass
+
+
+def feed(x, y):
+ """Feed salamander."""
+ pass
+
+
+class Migration(migrations.Migration):
+ dependencies = [
+ ("migrations", "0004_fourth"),
+ ]
+
+ operations = [
+ migrations.RunPython(migrations.RunPython.noop),
+ migrations.RunPython(grow_tail),
+ migrations.RunPython(feed, migrations.RunPython.noop),
+ ]
diff --git a/testbed/django__django/tests/migrations/test_migrations_plan/__init__.py b/testbed/django__django/tests/migrations/test_migrations_plan/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testbed/django__django/tests/migrations/test_migrations_private/.util.py b/testbed/django__django/tests/migrations/test_migrations_private/.util.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testbed/django__django/tests/migrations/test_migrations_private/0001_initial.py b/testbed/django__django/tests/migrations/test_migrations_private/0001_initial.py
new file mode 100644
index 0000000000000000000000000000000000000000..bd613aa95e0e71fa0ab0fc899baebf5e399b13ae
--- /dev/null
+++ b/testbed/django__django/tests/migrations/test_migrations_private/0001_initial.py
@@ -0,0 +1,5 @@
+from django.db import migrations
+
+
+class Migration(migrations.Migration):
+ pass
diff --git a/testbed/django__django/tests/migrations/test_migrations_private/__init__.py b/testbed/django__django/tests/migrations/test_migrations_private/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testbed/django__django/tests/migrations/test_migrations_private/_util.py b/testbed/django__django/tests/migrations/test_migrations_private/_util.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testbed/django__django/tests/migrations/test_migrations_private/~util.py b/testbed/django__django/tests/migrations/test_migrations_private/~util.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testbed/django__django/tests/migrations/test_migrations_run_before/0001_initial.py b/testbed/django__django/tests/migrations/test_migrations_run_before/0001_initial.py
new file mode 100644
index 0000000000000000000000000000000000000000..8ff77e0fe624f254ddcaac75dff378d3b2f095fd
--- /dev/null
+++ b/testbed/django__django/tests/migrations/test_migrations_run_before/0001_initial.py
@@ -0,0 +1,14 @@
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+ operations = [
+ migrations.CreateModel(
+ "Salamander",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ("size", models.IntegerField(default=0)),
+ ("silly_field", models.BooleanField(default=False)),
+ ],
+ ),
+ ]
diff --git a/testbed/django__django/tests/migrations/test_migrations_run_before/0002_second.py b/testbed/django__django/tests/migrations/test_migrations_run_before/0002_second.py
new file mode 100644
index 0000000000000000000000000000000000000000..0e0a9e81f6a4cc47b33c23320a73d20122508747
--- /dev/null
+++ b/testbed/django__django/tests/migrations/test_migrations_run_before/0002_second.py
@@ -0,0 +1,20 @@
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+ dependencies = [
+ ("migrations", "0001_initial"),
+ ]
+
+ operations = [
+ migrations.CreateModel(
+ "Book",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ (
+ "author",
+ models.ForeignKey("migrations.Author", models.SET_NULL, null=True),
+ ),
+ ],
+ )
+ ]
diff --git a/testbed/django__django/tests/migrations/test_migrations_run_before/0003_third.py b/testbed/django__django/tests/migrations/test_migrations_run_before/0003_third.py
new file mode 100644
index 0000000000000000000000000000000000000000..ea6b2f38774ee92e6f7e326219da1f14cb5eb90f
--- /dev/null
+++ b/testbed/django__django/tests/migrations/test_migrations_run_before/0003_third.py
@@ -0,0 +1,27 @@
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+ """
+ This is a wee bit crazy, but it's just to show that run_before works.
+ """
+
+ dependencies = [
+ ("migrations", "0001_initial"),
+ ]
+
+ run_before = [
+ ("migrations", "0002_second"),
+ ]
+
+ operations = [
+ migrations.CreateModel(
+ "Author",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ("name", models.CharField(max_length=255)),
+ ("slug", models.SlugField(null=True)),
+ ("age", models.IntegerField(default=0)),
+ ],
+ )
+ ]
diff --git a/testbed/django__django/tests/migrations/test_migrations_run_before/__init__.py b/testbed/django__django/tests/migrations/test_migrations_run_before/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testbed/django__django/tests/migrations/test_migrations_squashed/0001_initial.py b/testbed/django__django/tests/migrations/test_migrations_squashed/0001_initial.py
new file mode 100644
index 0000000000000000000000000000000000000000..42aadab7a003546192cdd83e28fa7e12b9eb4a38
--- /dev/null
+++ b/testbed/django__django/tests/migrations/test_migrations_squashed/0001_initial.py
@@ -0,0 +1,23 @@
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+ operations = [
+ migrations.CreateModel(
+ "Author",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ("name", models.CharField(max_length=255)),
+ ("slug", models.SlugField(null=True)),
+ ("age", models.IntegerField(default=0)),
+ ("silly_field", models.BooleanField(default=False)),
+ ],
+ ),
+ migrations.CreateModel(
+ "Tribble",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ("fluffy", models.BooleanField(default=True)),
+ ],
+ ),
+ ]
diff --git a/testbed/django__django/tests/migrations/test_migrations_squashed/0001_squashed_0002.py b/testbed/django__django/tests/migrations/test_migrations_squashed/0001_squashed_0002.py
new file mode 100644
index 0000000000000000000000000000000000000000..8af697aedcfc98ada45ab81e4b99856fd0e006d1
--- /dev/null
+++ b/testbed/django__django/tests/migrations/test_migrations_squashed/0001_squashed_0002.py
@@ -0,0 +1,31 @@
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+ replaces = [
+ ("migrations", "0001_initial"),
+ ("migrations", "0002_second"),
+ ]
+
+ operations = [
+ migrations.CreateModel(
+ "Author",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ("name", models.CharField(max_length=255)),
+ ("slug", models.SlugField(null=True)),
+ ("age", models.IntegerField(default=0)),
+ ("rating", models.IntegerField(default=0)),
+ ],
+ ),
+ migrations.CreateModel(
+ "Book",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ (
+ "author",
+ models.ForeignKey("migrations.Author", models.SET_NULL, null=True),
+ ),
+ ],
+ ),
+ ]
diff --git a/testbed/django__django/tests/migrations/test_migrations_squashed/0002_second.py b/testbed/django__django/tests/migrations/test_migrations_squashed/0002_second.py
new file mode 100644
index 0000000000000000000000000000000000000000..55d3b9aaad88c8bab80ac803186ff4ac93cd1d3b
--- /dev/null
+++ b/testbed/django__django/tests/migrations/test_migrations_squashed/0002_second.py
@@ -0,0 +1,21 @@
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+ dependencies = [("migrations", "0001_initial")]
+
+ operations = [
+ migrations.DeleteModel("Tribble"),
+ migrations.RemoveField("Author", "silly_field"),
+ migrations.AddField("Author", "rating", models.IntegerField(default=0)),
+ migrations.CreateModel(
+ "Book",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ (
+ "author",
+ models.ForeignKey("migrations.Author", models.SET_NULL, null=True),
+ ),
+ ],
+ ),
+ ]
diff --git a/testbed/django__django/tests/migrations/test_migrations_squashed/__init__.py b/testbed/django__django/tests/migrations/test_migrations_squashed/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testbed/django__django/tests/migrations/test_migrations_squashed_complex/1_auto.py b/testbed/django__django/tests/migrations/test_migrations_squashed_complex/1_auto.py
new file mode 100644
index 0000000000000000000000000000000000000000..2e5fb93b754317decc44d29edf17cbc92736c9b0
--- /dev/null
+++ b/testbed/django__django/tests/migrations/test_migrations_squashed_complex/1_auto.py
@@ -0,0 +1,5 @@
+from django.db import migrations
+
+
+class Migration(migrations.Migration):
+ operations = [migrations.RunPython(migrations.RunPython.noop)]
diff --git a/testbed/django__django/tests/migrations/test_migrations_squashed_complex/2_auto.py b/testbed/django__django/tests/migrations/test_migrations_squashed_complex/2_auto.py
new file mode 100644
index 0000000000000000000000000000000000000000..88678d4e596e20d2a03e2b36407b1614a433a0f1
--- /dev/null
+++ b/testbed/django__django/tests/migrations/test_migrations_squashed_complex/2_auto.py
@@ -0,0 +1,7 @@
+from django.db import migrations
+
+
+class Migration(migrations.Migration):
+ dependencies = [("migrations", "1_auto")]
+
+ operations = [migrations.RunPython(migrations.RunPython.noop)]
diff --git a/testbed/django__django/tests/migrations/test_migrations_squashed_complex/3_auto.py b/testbed/django__django/tests/migrations/test_migrations_squashed_complex/3_auto.py
new file mode 100644
index 0000000000000000000000000000000000000000..b774a6cec564baf294a59a3be8f9ed2c02edbbaf
--- /dev/null
+++ b/testbed/django__django/tests/migrations/test_migrations_squashed_complex/3_auto.py
@@ -0,0 +1,7 @@
+from django.db import migrations
+
+
+class Migration(migrations.Migration):
+ dependencies = [("migrations", "2_auto")]
+
+ operations = [migrations.RunPython(migrations.RunPython.noop)]
diff --git a/testbed/django__django/tests/migrations/test_migrations_squashed_complex/3_squashed_5.py b/testbed/django__django/tests/migrations/test_migrations_squashed_complex/3_squashed_5.py
new file mode 100644
index 0000000000000000000000000000000000000000..bf7fdaf718a969e76c41a6658c0b2157009360f1
--- /dev/null
+++ b/testbed/django__django/tests/migrations/test_migrations_squashed_complex/3_squashed_5.py
@@ -0,0 +1,13 @@
+from django.db import migrations
+
+
+class Migration(migrations.Migration):
+ replaces = [
+ ("migrations", "3_auto"),
+ ("migrations", "4_auto"),
+ ("migrations", "5_auto"),
+ ]
+
+ dependencies = [("migrations", "2_auto")]
+
+ operations = [migrations.RunPython(migrations.RunPython.noop)]
diff --git a/testbed/django__django/tests/migrations/test_migrations_squashed_complex/4_auto.py b/testbed/django__django/tests/migrations/test_migrations_squashed_complex/4_auto.py
new file mode 100644
index 0000000000000000000000000000000000000000..a1f422a111ea18435c7662ca08b380cf286c1ae1
--- /dev/null
+++ b/testbed/django__django/tests/migrations/test_migrations_squashed_complex/4_auto.py
@@ -0,0 +1,7 @@
+from django.db import migrations
+
+
+class Migration(migrations.Migration):
+ dependencies = [("migrations", "3_auto")]
+
+ operations = [migrations.RunPython(migrations.RunPython.noop)]
diff --git a/testbed/django__django/tests/migrations/test_migrations_squashed_complex/5_auto.py b/testbed/django__django/tests/migrations/test_migrations_squashed_complex/5_auto.py
new file mode 100644
index 0000000000000000000000000000000000000000..2b43fcf0163c1eb3636a67b2446a71439134baeb
--- /dev/null
+++ b/testbed/django__django/tests/migrations/test_migrations_squashed_complex/5_auto.py
@@ -0,0 +1,7 @@
+from django.db import migrations
+
+
+class Migration(migrations.Migration):
+ dependencies = [("migrations", "4_auto")]
+
+ operations = [migrations.RunPython(migrations.RunPython.noop)]
diff --git a/testbed/django__django/tests/migrations/test_migrations_squashed_complex/6_auto.py b/testbed/django__django/tests/migrations/test_migrations_squashed_complex/6_auto.py
new file mode 100644
index 0000000000000000000000000000000000000000..52a06fb8190ee97460efcad5544c8b7ae6d04ee6
--- /dev/null
+++ b/testbed/django__django/tests/migrations/test_migrations_squashed_complex/6_auto.py
@@ -0,0 +1,7 @@
+from django.db import migrations
+
+
+class Migration(migrations.Migration):
+ dependencies = [("migrations", "5_auto")]
+
+ operations = [migrations.RunPython(migrations.RunPython.noop)]
diff --git a/testbed/django__django/tests/migrations/test_migrations_squashed_complex/7_auto.py b/testbed/django__django/tests/migrations/test_migrations_squashed_complex/7_auto.py
new file mode 100644
index 0000000000000000000000000000000000000000..7d995e208c8e1e1fa10351addc6e32a2026c0fc0
--- /dev/null
+++ b/testbed/django__django/tests/migrations/test_migrations_squashed_complex/7_auto.py
@@ -0,0 +1,7 @@
+from django.db import migrations
+
+
+class Migration(migrations.Migration):
+ dependencies = [("migrations", "6_auto")]
+
+ operations = [migrations.RunPython(migrations.RunPython.noop)]
diff --git a/testbed/django__django/tests/migrations/test_migrations_squashed_complex/__init__.py b/testbed/django__django/tests/migrations/test_migrations_squashed_complex/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testbed/django__django/tests/migrations/test_migrations_squashed_complex_multi_apps/__init__.py b/testbed/django__django/tests/migrations/test_migrations_squashed_complex_multi_apps/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testbed/django__django/tests/migrations/test_migrations_squashed_complex_multi_apps/app1/1_auto.py b/testbed/django__django/tests/migrations/test_migrations_squashed_complex_multi_apps/app1/1_auto.py
new file mode 100644
index 0000000000000000000000000000000000000000..2e5fb93b754317decc44d29edf17cbc92736c9b0
--- /dev/null
+++ b/testbed/django__django/tests/migrations/test_migrations_squashed_complex_multi_apps/app1/1_auto.py
@@ -0,0 +1,5 @@
+from django.db import migrations
+
+
+class Migration(migrations.Migration):
+ operations = [migrations.RunPython(migrations.RunPython.noop)]
diff --git a/testbed/django__django/tests/migrations/test_migrations_squashed_complex_multi_apps/app1/2_auto.py b/testbed/django__django/tests/migrations/test_migrations_squashed_complex_multi_apps/app1/2_auto.py
new file mode 100644
index 0000000000000000000000000000000000000000..606802b8c9e0fc3281900927389189996100b106
--- /dev/null
+++ b/testbed/django__django/tests/migrations/test_migrations_squashed_complex_multi_apps/app1/2_auto.py
@@ -0,0 +1,7 @@
+from django.db import migrations
+
+
+class Migration(migrations.Migration):
+ dependencies = [("app1", "1_auto")]
+
+ operations = [migrations.RunPython(migrations.RunPython.noop)]
diff --git a/testbed/django__django/tests/migrations/test_migrations_squashed_complex_multi_apps/app1/2_squashed_3.py b/testbed/django__django/tests/migrations/test_migrations_squashed_complex_multi_apps/app1/2_squashed_3.py
new file mode 100644
index 0000000000000000000000000000000000000000..71421b9fb62750940eab52891b0ecd8b26332fbf
--- /dev/null
+++ b/testbed/django__django/tests/migrations/test_migrations_squashed_complex_multi_apps/app1/2_squashed_3.py
@@ -0,0 +1,12 @@
+from django.db import migrations
+
+
+class Migration(migrations.Migration):
+ replaces = [
+ ("app1", "2_auto"),
+ ("app1", "3_auto"),
+ ]
+
+ dependencies = [("app1", "1_auto"), ("app2", "2_auto")]
+
+ operations = [migrations.RunPython(migrations.RunPython.noop)]
diff --git a/testbed/django__django/tests/migrations/test_migrations_squashed_complex_multi_apps/app1/3_auto.py b/testbed/django__django/tests/migrations/test_migrations_squashed_complex_multi_apps/app1/3_auto.py
new file mode 100644
index 0000000000000000000000000000000000000000..33cffdbaf687b859b3eec1d7ce1cc9cc53138167
--- /dev/null
+++ b/testbed/django__django/tests/migrations/test_migrations_squashed_complex_multi_apps/app1/3_auto.py
@@ -0,0 +1,7 @@
+from django.db import migrations
+
+
+class Migration(migrations.Migration):
+ dependencies = [("app1", "2_auto"), ("app2", "2_auto")]
+
+ operations = [migrations.RunPython(migrations.RunPython.noop)]
diff --git a/testbed/django__django/tests/migrations/test_migrations_squashed_complex_multi_apps/app1/4_auto.py b/testbed/django__django/tests/migrations/test_migrations_squashed_complex_multi_apps/app1/4_auto.py
new file mode 100644
index 0000000000000000000000000000000000000000..f584661820f8b2e131eb95d5d79672dd26f2fd9e
--- /dev/null
+++ b/testbed/django__django/tests/migrations/test_migrations_squashed_complex_multi_apps/app1/4_auto.py
@@ -0,0 +1,7 @@
+from django.db import migrations
+
+
+class Migration(migrations.Migration):
+ dependencies = [("app1", "3_auto")]
+
+ operations = [migrations.RunPython(migrations.RunPython.noop)]
diff --git a/testbed/django__django/tests/migrations/test_migrations_squashed_complex_multi_apps/app1/__init__.py b/testbed/django__django/tests/migrations/test_migrations_squashed_complex_multi_apps/app1/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testbed/django__django/tests/migrations/test_migrations_squashed_complex_multi_apps/app2/1_auto.py b/testbed/django__django/tests/migrations/test_migrations_squashed_complex_multi_apps/app2/1_auto.py
new file mode 100644
index 0000000000000000000000000000000000000000..606802b8c9e0fc3281900927389189996100b106
--- /dev/null
+++ b/testbed/django__django/tests/migrations/test_migrations_squashed_complex_multi_apps/app2/1_auto.py
@@ -0,0 +1,7 @@
+from django.db import migrations
+
+
+class Migration(migrations.Migration):
+ dependencies = [("app1", "1_auto")]
+
+ operations = [migrations.RunPython(migrations.RunPython.noop)]
diff --git a/testbed/django__django/tests/migrations/test_migrations_squashed_complex_multi_apps/app2/1_squashed_2.py b/testbed/django__django/tests/migrations/test_migrations_squashed_complex_multi_apps/app2/1_squashed_2.py
new file mode 100644
index 0000000000000000000000000000000000000000..0fbc0d7abbf4491b800f2e8c20b961816e72f3fc
--- /dev/null
+++ b/testbed/django__django/tests/migrations/test_migrations_squashed_complex_multi_apps/app2/1_squashed_2.py
@@ -0,0 +1,12 @@
+from django.db import migrations
+
+
+class Migration(migrations.Migration):
+ replaces = [
+ ("app2", "1_auto"),
+ ("app2", "2_auto"),
+ ]
+
+ dependencies = [("app1", "1_auto")]
+
+ operations = [migrations.RunPython(migrations.RunPython.noop)]
diff --git a/testbed/django__django/tests/migrations/test_migrations_squashed_complex_multi_apps/app2/2_auto.py b/testbed/django__django/tests/migrations/test_migrations_squashed_complex_multi_apps/app2/2_auto.py
new file mode 100644
index 0000000000000000000000000000000000000000..9ddbf9ace56c2225e1b1ea516d05d1152eddd31d
--- /dev/null
+++ b/testbed/django__django/tests/migrations/test_migrations_squashed_complex_multi_apps/app2/2_auto.py
@@ -0,0 +1,7 @@
+from django.db import migrations
+
+
+class Migration(migrations.Migration):
+ dependencies = [("app2", "1_auto")]
+
+ operations = [migrations.RunPython(migrations.RunPython.noop)]
diff --git a/testbed/django__django/tests/migrations/test_migrations_squashed_complex_multi_apps/app2/__init__.py b/testbed/django__django/tests/migrations/test_migrations_squashed_complex_multi_apps/app2/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testbed/django__django/tests/migrations/test_migrations_squashed_erroneous/1_auto.py b/testbed/django__django/tests/migrations/test_migrations_squashed_erroneous/1_auto.py
new file mode 100644
index 0000000000000000000000000000000000000000..2e5fb93b754317decc44d29edf17cbc92736c9b0
--- /dev/null
+++ b/testbed/django__django/tests/migrations/test_migrations_squashed_erroneous/1_auto.py
@@ -0,0 +1,5 @@
+from django.db import migrations
+
+
+class Migration(migrations.Migration):
+ operations = [migrations.RunPython(migrations.RunPython.noop)]
diff --git a/testbed/django__django/tests/migrations/test_migrations_squashed_erroneous/2_auto.py b/testbed/django__django/tests/migrations/test_migrations_squashed_erroneous/2_auto.py
new file mode 100644
index 0000000000000000000000000000000000000000..88678d4e596e20d2a03e2b36407b1614a433a0f1
--- /dev/null
+++ b/testbed/django__django/tests/migrations/test_migrations_squashed_erroneous/2_auto.py
@@ -0,0 +1,7 @@
+from django.db import migrations
+
+
+class Migration(migrations.Migration):
+ dependencies = [("migrations", "1_auto")]
+
+ operations = [migrations.RunPython(migrations.RunPython.noop)]
diff --git a/testbed/django__django/tests/migrations/test_migrations_squashed_erroneous/3_squashed_5.py b/testbed/django__django/tests/migrations/test_migrations_squashed_erroneous/3_squashed_5.py
new file mode 100644
index 0000000000000000000000000000000000000000..bf7fdaf718a969e76c41a6658c0b2157009360f1
--- /dev/null
+++ b/testbed/django__django/tests/migrations/test_migrations_squashed_erroneous/3_squashed_5.py
@@ -0,0 +1,13 @@
+from django.db import migrations
+
+
+class Migration(migrations.Migration):
+ replaces = [
+ ("migrations", "3_auto"),
+ ("migrations", "4_auto"),
+ ("migrations", "5_auto"),
+ ]
+
+ dependencies = [("migrations", "2_auto")]
+
+ operations = [migrations.RunPython(migrations.RunPython.noop)]
diff --git a/testbed/django__django/tests/migrations/test_migrations_squashed_erroneous/6_auto.py b/testbed/django__django/tests/migrations/test_migrations_squashed_erroneous/6_auto.py
new file mode 100644
index 0000000000000000000000000000000000000000..52a06fb8190ee97460efcad5544c8b7ae6d04ee6
--- /dev/null
+++ b/testbed/django__django/tests/migrations/test_migrations_squashed_erroneous/6_auto.py
@@ -0,0 +1,7 @@
+from django.db import migrations
+
+
+class Migration(migrations.Migration):
+ dependencies = [("migrations", "5_auto")]
+
+ operations = [migrations.RunPython(migrations.RunPython.noop)]
diff --git a/testbed/django__django/tests/migrations/test_migrations_squashed_erroneous/7_auto.py b/testbed/django__django/tests/migrations/test_migrations_squashed_erroneous/7_auto.py
new file mode 100644
index 0000000000000000000000000000000000000000..7d995e208c8e1e1fa10351addc6e32a2026c0fc0
--- /dev/null
+++ b/testbed/django__django/tests/migrations/test_migrations_squashed_erroneous/7_auto.py
@@ -0,0 +1,7 @@
+from django.db import migrations
+
+
+class Migration(migrations.Migration):
+ dependencies = [("migrations", "6_auto")]
+
+ operations = [migrations.RunPython(migrations.RunPython.noop)]
diff --git a/testbed/django__django/tests/migrations/test_migrations_squashed_erroneous/__init__.py b/testbed/django__django/tests/migrations/test_migrations_squashed_erroneous/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testbed/django__django/tests/migrations/test_migrations_squashed_extra/0001_initial.py b/testbed/django__django/tests/migrations/test_migrations_squashed_extra/0001_initial.py
new file mode 100644
index 0000000000000000000000000000000000000000..bd613aa95e0e71fa0ab0fc899baebf5e399b13ae
--- /dev/null
+++ b/testbed/django__django/tests/migrations/test_migrations_squashed_extra/0001_initial.py
@@ -0,0 +1,5 @@
+from django.db import migrations
+
+
+class Migration(migrations.Migration):
+ pass
diff --git a/testbed/django__django/tests/migrations/test_migrations_squashed_extra/0001_squashed_0002.py b/testbed/django__django/tests/migrations/test_migrations_squashed_extra/0001_squashed_0002.py
new file mode 100644
index 0000000000000000000000000000000000000000..9d5581cc59e87379df9a3d3134d800b4b8189bf8
--- /dev/null
+++ b/testbed/django__django/tests/migrations/test_migrations_squashed_extra/0001_squashed_0002.py
@@ -0,0 +1,8 @@
+from django.db import migrations
+
+
+class Migration(migrations.Migration):
+ replaces = [
+ ("migrations", "0001_initial"),
+ ("migrations", "0002_second"),
+ ]
diff --git a/testbed/django__django/tests/migrations/test_migrations_squashed_extra/0002_second.py b/testbed/django__django/tests/migrations/test_migrations_squashed_extra/0002_second.py
new file mode 100644
index 0000000000000000000000000000000000000000..5ca710feb6ee6f91e6d99de9339cbcbef3851800
--- /dev/null
+++ b/testbed/django__django/tests/migrations/test_migrations_squashed_extra/0002_second.py
@@ -0,0 +1,5 @@
+from django.db import migrations
+
+
+class Migration(migrations.Migration):
+ dependencies = [("migrations", "0001_initial")]
diff --git a/testbed/django__django/tests/migrations/test_migrations_squashed_extra/0003_third.py b/testbed/django__django/tests/migrations/test_migrations_squashed_extra/0003_third.py
new file mode 100644
index 0000000000000000000000000000000000000000..cf27aa2990cb5efeb11571a43d1a5f752bc85bb6
--- /dev/null
+++ b/testbed/django__django/tests/migrations/test_migrations_squashed_extra/0003_third.py
@@ -0,0 +1,5 @@
+from django.db import migrations
+
+
+class Migration(migrations.Migration):
+ dependencies = [("migrations", "0002_second")]
diff --git a/testbed/django__django/tests/migrations/test_migrations_squashed_extra/__init__.py b/testbed/django__django/tests/migrations/test_migrations_squashed_extra/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testbed/django__django/tests/migrations/test_migrations_squashed_no_replaces/0001_squashed_0002.py b/testbed/django__django/tests/migrations/test_migrations_squashed_no_replaces/0001_squashed_0002.py
new file mode 100644
index 0000000000000000000000000000000000000000..a6049cade8b7e2b3f68300ff3ebf2e0c0c2652de
--- /dev/null
+++ b/testbed/django__django/tests/migrations/test_migrations_squashed_no_replaces/0001_squashed_0002.py
@@ -0,0 +1,23 @@
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+ operations = [
+ migrations.CreateModel(
+ "Author",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ("name", models.CharField(max_length=255)),
+ ],
+ ),
+ migrations.CreateModel(
+ "Book",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ (
+ "author",
+ models.ForeignKey("migrations.Author", models.SET_NULL, null=True),
+ ),
+ ],
+ ),
+ ]
diff --git a/testbed/django__django/tests/migrations/test_migrations_squashed_no_replaces/__init__.py b/testbed/django__django/tests/migrations/test_migrations_squashed_no_replaces/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testbed/django__django/tests/migrations/test_migrations_squashed_ref_squashed/__init__.py b/testbed/django__django/tests/migrations/test_migrations_squashed_ref_squashed/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testbed/django__django/tests/migrations/test_migrations_squashed_ref_squashed/app1/1_auto.py b/testbed/django__django/tests/migrations/test_migrations_squashed_ref_squashed/app1/1_auto.py
new file mode 100644
index 0000000000000000000000000000000000000000..bd613aa95e0e71fa0ab0fc899baebf5e399b13ae
--- /dev/null
+++ b/testbed/django__django/tests/migrations/test_migrations_squashed_ref_squashed/app1/1_auto.py
@@ -0,0 +1,5 @@
+from django.db import migrations
+
+
+class Migration(migrations.Migration):
+ pass
diff --git a/testbed/django__django/tests/migrations/test_migrations_squashed_ref_squashed/app1/2_auto.py b/testbed/django__django/tests/migrations/test_migrations_squashed_ref_squashed/app1/2_auto.py
new file mode 100644
index 0000000000000000000000000000000000000000..087b76f19007c720064c1520907f3cc5fea61c99
--- /dev/null
+++ b/testbed/django__django/tests/migrations/test_migrations_squashed_ref_squashed/app1/2_auto.py
@@ -0,0 +1,5 @@
+from django.db import migrations
+
+
+class Migration(migrations.Migration):
+ dependencies = [("app1", "1_auto")]
diff --git a/testbed/django__django/tests/migrations/test_migrations_squashed_ref_squashed/app1/2_squashed_3.py b/testbed/django__django/tests/migrations/test_migrations_squashed_ref_squashed/app1/2_squashed_3.py
new file mode 100644
index 0000000000000000000000000000000000000000..c7101844b9cb36d9b23c6a129e3e4b865c67d3a2
--- /dev/null
+++ b/testbed/django__django/tests/migrations/test_migrations_squashed_ref_squashed/app1/2_squashed_3.py
@@ -0,0 +1,10 @@
+from django.db import migrations
+
+
+class Migration(migrations.Migration):
+ replaces = [
+ ("app1", "2_auto"),
+ ("app1", "3_auto"),
+ ]
+
+ dependencies = [("app1", "1_auto"), ("app2", "1_squashed_2")]
diff --git a/testbed/django__django/tests/migrations/test_migrations_squashed_ref_squashed/app1/3_auto.py b/testbed/django__django/tests/migrations/test_migrations_squashed_ref_squashed/app1/3_auto.py
new file mode 100644
index 0000000000000000000000000000000000000000..5b08c2be394d1778686f88c5b499c025767e176d
--- /dev/null
+++ b/testbed/django__django/tests/migrations/test_migrations_squashed_ref_squashed/app1/3_auto.py
@@ -0,0 +1,5 @@
+from django.db import migrations
+
+
+class Migration(migrations.Migration):
+ dependencies = [("app1", "2_auto"), ("app2", "2_auto")]
diff --git a/testbed/django__django/tests/migrations/test_migrations_squashed_ref_squashed/app1/4_auto.py b/testbed/django__django/tests/migrations/test_migrations_squashed_ref_squashed/app1/4_auto.py
new file mode 100644
index 0000000000000000000000000000000000000000..59f66bcd95840cf476682ab833b455bb8f8aebb6
--- /dev/null
+++ b/testbed/django__django/tests/migrations/test_migrations_squashed_ref_squashed/app1/4_auto.py
@@ -0,0 +1,5 @@
+from django.db import migrations
+
+
+class Migration(migrations.Migration):
+ dependencies = [("app1", "2_squashed_3")]
diff --git a/testbed/django__django/tests/migrations/test_migrations_squashed_ref_squashed/app1/__init__.py b/testbed/django__django/tests/migrations/test_migrations_squashed_ref_squashed/app1/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testbed/django__django/tests/migrations/test_migrations_squashed_ref_squashed/app2/1_auto.py b/testbed/django__django/tests/migrations/test_migrations_squashed_ref_squashed/app2/1_auto.py
new file mode 100644
index 0000000000000000000000000000000000000000..087b76f19007c720064c1520907f3cc5fea61c99
--- /dev/null
+++ b/testbed/django__django/tests/migrations/test_migrations_squashed_ref_squashed/app2/1_auto.py
@@ -0,0 +1,5 @@
+from django.db import migrations
+
+
+class Migration(migrations.Migration):
+ dependencies = [("app1", "1_auto")]
diff --git a/testbed/django__django/tests/migrations/test_migrations_squashed_ref_squashed/app2/1_squashed_2.py b/testbed/django__django/tests/migrations/test_migrations_squashed_ref_squashed/app2/1_squashed_2.py
new file mode 100644
index 0000000000000000000000000000000000000000..70672398867276b33f662d7626e8aa48d8091173
--- /dev/null
+++ b/testbed/django__django/tests/migrations/test_migrations_squashed_ref_squashed/app2/1_squashed_2.py
@@ -0,0 +1,10 @@
+from django.db import migrations
+
+
+class Migration(migrations.Migration):
+ replaces = [
+ ("app2", "1_auto"),
+ ("app2", "2_auto"),
+ ]
+
+ dependencies = [("app1", "1_auto")]
diff --git a/testbed/django__django/tests/migrations/test_migrations_squashed_ref_squashed/app2/2_auto.py b/testbed/django__django/tests/migrations/test_migrations_squashed_ref_squashed/app2/2_auto.py
new file mode 100644
index 0000000000000000000000000000000000000000..2937f3c74e8603cd5ecad907cfb6a21157eaf626
--- /dev/null
+++ b/testbed/django__django/tests/migrations/test_migrations_squashed_ref_squashed/app2/2_auto.py
@@ -0,0 +1,5 @@
+from django.db import migrations
+
+
+class Migration(migrations.Migration):
+ dependencies = [("app2", "1_auto")]
diff --git a/testbed/django__django/tests/migrations/test_migrations_squashed_ref_squashed/app2/__init__.py b/testbed/django__django/tests/migrations/test_migrations_squashed_ref_squashed/app2/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testbed/django__django/tests/migrations/test_migrations_unmigdep/0001_initial.py b/testbed/django__django/tests/migrations/test_migrations_unmigdep/0001_initial.py
new file mode 100644
index 0000000000000000000000000000000000000000..1ce161761187991ce7645e5a3ed8b3cb30e766b8
--- /dev/null
+++ b/testbed/django__django/tests/migrations/test_migrations_unmigdep/0001_initial.py
@@ -0,0 +1,17 @@
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+ dependencies = [
+ ("auth", "__first__"),
+ ]
+
+ operations = [
+ migrations.CreateModel(
+ "Book",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ("user", models.ForeignKey("auth.User", models.SET_NULL, null=True)),
+ ],
+ )
+ ]
diff --git a/testbed/django__django/tests/migrations/test_migrations_unmigdep/__init__.py b/testbed/django__django/tests/migrations/test_migrations_unmigdep/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testbed/django__django/tests/migrations/test_multidb.py b/testbed/django__django/tests/migrations/test_multidb.py
new file mode 100644
index 0000000000000000000000000000000000000000..7bf5d51454af695c652d82c801bd091985cc8d16
--- /dev/null
+++ b/testbed/django__django/tests/migrations/test_multidb.py
@@ -0,0 +1,187 @@
+from django.db import connection, migrations, models
+from django.db.migrations.state import ProjectState
+from django.test import override_settings
+
+from .test_base import OperationTestBase
+
+
+class AgnosticRouter:
+ """
+ A router that doesn't have an opinion regarding migrating.
+ """
+
+ def allow_migrate(self, db, app_label, **hints):
+ return None
+
+
+class MigrateNothingRouter:
+ """
+ A router that doesn't allow migrating.
+ """
+
+ def allow_migrate(self, db, app_label, **hints):
+ return False
+
+
+class MigrateEverythingRouter:
+ """
+ A router that always allows migrating.
+ """
+
+ def allow_migrate(self, db, app_label, **hints):
+ return True
+
+
+class MigrateWhenFooRouter:
+ """
+ A router that allows migrating depending on a hint.
+ """
+
+ def allow_migrate(self, db, app_label, **hints):
+ return hints.get("foo", False)
+
+
+class MultiDBOperationTests(OperationTestBase):
+ databases = {"default", "other"}
+
+ def _test_create_model(self, app_label, should_run):
+ """
+ CreateModel honors multi-db settings.
+ """
+ operation = migrations.CreateModel(
+ "Pony",
+ [("id", models.AutoField(primary_key=True))],
+ )
+ # Test the state alteration
+ project_state = ProjectState()
+ new_state = project_state.clone()
+ operation.state_forwards(app_label, new_state)
+ # Test the database alteration
+ self.assertTableNotExists("%s_pony" % app_label)
+ with connection.schema_editor() as editor:
+ operation.database_forwards(app_label, editor, project_state, new_state)
+ if should_run:
+ self.assertTableExists("%s_pony" % app_label)
+ else:
+ self.assertTableNotExists("%s_pony" % app_label)
+ # And test reversal
+ with connection.schema_editor() as editor:
+ operation.database_backwards(app_label, editor, new_state, project_state)
+ self.assertTableNotExists("%s_pony" % app_label)
+
+ @override_settings(DATABASE_ROUTERS=[AgnosticRouter()])
+ def test_create_model(self):
+ """
+ Test when router doesn't have an opinion (i.e. CreateModel should run).
+ """
+ self._test_create_model("test_mltdb_crmo", should_run=True)
+
+ @override_settings(DATABASE_ROUTERS=[MigrateNothingRouter()])
+ def test_create_model2(self):
+ """
+ Test when router returns False (i.e. CreateModel shouldn't run).
+ """
+ self._test_create_model("test_mltdb_crmo2", should_run=False)
+
+ @override_settings(DATABASE_ROUTERS=[MigrateEverythingRouter()])
+ def test_create_model3(self):
+ """
+ Test when router returns True (i.e. CreateModel should run).
+ """
+ self._test_create_model("test_mltdb_crmo3", should_run=True)
+
+ def test_create_model4(self):
+ """
+ Test multiple routers.
+ """
+ with override_settings(DATABASE_ROUTERS=[AgnosticRouter(), AgnosticRouter()]):
+ self._test_create_model("test_mltdb_crmo4", should_run=True)
+ with override_settings(
+ DATABASE_ROUTERS=[MigrateNothingRouter(), MigrateEverythingRouter()]
+ ):
+ self._test_create_model("test_mltdb_crmo4", should_run=False)
+ with override_settings(
+ DATABASE_ROUTERS=[MigrateEverythingRouter(), MigrateNothingRouter()]
+ ):
+ self._test_create_model("test_mltdb_crmo4", should_run=True)
+
+ def _test_run_sql(self, app_label, should_run, hints=None):
+ with override_settings(DATABASE_ROUTERS=[MigrateEverythingRouter()]):
+ project_state = self.set_up_test_model(app_label)
+
+ sql = """
+ INSERT INTO {0}_pony (pink, weight) VALUES (1, 3.55);
+ INSERT INTO {0}_pony (pink, weight) VALUES (3, 5.0);
+ """.format(
+ app_label
+ )
+
+ operation = migrations.RunSQL(sql, hints=hints or {})
+ # Test the state alteration does nothing
+ new_state = project_state.clone()
+ operation.state_forwards(app_label, new_state)
+ self.assertEqual(new_state, project_state)
+ # Test the database alteration
+ self.assertEqual(
+ project_state.apps.get_model(app_label, "Pony").objects.count(), 0
+ )
+ with connection.schema_editor() as editor:
+ operation.database_forwards(app_label, editor, project_state, new_state)
+ Pony = project_state.apps.get_model(app_label, "Pony")
+ if should_run:
+ self.assertEqual(Pony.objects.count(), 2)
+ else:
+ self.assertEqual(Pony.objects.count(), 0)
+
+ @override_settings(DATABASE_ROUTERS=[MigrateNothingRouter()])
+ def test_run_sql_migrate_nothing_router(self):
+ self._test_run_sql("test_mltdb_runsql", should_run=False)
+
+ @override_settings(DATABASE_ROUTERS=[MigrateWhenFooRouter()])
+ def test_run_sql_migrate_foo_router_without_hints(self):
+ self._test_run_sql("test_mltdb_runsql2", should_run=False)
+
+ @override_settings(DATABASE_ROUTERS=[MigrateWhenFooRouter()])
+ def test_run_sql_migrate_foo_router_with_hints(self):
+ self._test_run_sql("test_mltdb_runsql3", should_run=True, hints={"foo": True})
+
+ def _test_run_python(self, app_label, should_run, hints=None):
+ with override_settings(DATABASE_ROUTERS=[MigrateEverythingRouter()]):
+ project_state = self.set_up_test_model(app_label)
+
+ # Create the operation
+ def inner_method(models, schema_editor):
+ Pony = models.get_model(app_label, "Pony")
+ Pony.objects.create(pink=1, weight=3.55)
+ Pony.objects.create(weight=5)
+
+ operation = migrations.RunPython(inner_method, hints=hints or {})
+ # Test the state alteration does nothing
+ new_state = project_state.clone()
+ operation.state_forwards(app_label, new_state)
+ self.assertEqual(new_state, project_state)
+ # Test the database alteration
+ self.assertEqual(
+ project_state.apps.get_model(app_label, "Pony").objects.count(), 0
+ )
+ with connection.schema_editor() as editor:
+ operation.database_forwards(app_label, editor, project_state, new_state)
+ Pony = project_state.apps.get_model(app_label, "Pony")
+ if should_run:
+ self.assertEqual(Pony.objects.count(), 2)
+ else:
+ self.assertEqual(Pony.objects.count(), 0)
+
+ @override_settings(DATABASE_ROUTERS=[MigrateNothingRouter()])
+ def test_run_python_migrate_nothing_router(self):
+ self._test_run_python("test_mltdb_runpython", should_run=False)
+
+ @override_settings(DATABASE_ROUTERS=[MigrateWhenFooRouter()])
+ def test_run_python_migrate_foo_router_without_hints(self):
+ self._test_run_python("test_mltdb_runpython2", should_run=False)
+
+ @override_settings(DATABASE_ROUTERS=[MigrateWhenFooRouter()])
+ def test_run_python_migrate_foo_router_with_hints(self):
+ self._test_run_python(
+ "test_mltdb_runpython3", should_run=True, hints={"foo": True}
+ )
diff --git a/testbed/django__django/tests/migrations/test_operations.py b/testbed/django__django/tests/migrations/test_operations.py
new file mode 100644
index 0000000000000000000000000000000000000000..e377e4ca64080fb6f09cc2fc6a69c5c0e0385382
--- /dev/null
+++ b/testbed/django__django/tests/migrations/test_operations.py
@@ -0,0 +1,5953 @@
+import math
+
+from django.core.exceptions import FieldDoesNotExist
+from django.db import IntegrityError, connection, migrations, models, transaction
+from django.db.migrations.migration import Migration
+from django.db.migrations.operations.fields import FieldOperation
+from django.db.migrations.state import ModelState, ProjectState
+from django.db.models.expressions import Value
+from django.db.models.functions import Abs, Pi
+from django.db.transaction import atomic
+from django.test import (
+ SimpleTestCase,
+ ignore_warnings,
+ override_settings,
+ skipIfDBFeature,
+ skipUnlessDBFeature,
+)
+from django.test.utils import CaptureQueriesContext
+from django.utils.deprecation import RemovedInDjango51Warning
+
+from .models import FoodManager, FoodQuerySet, UnicodeModel
+from .test_base import OperationTestBase
+
+
+class Mixin:
+ pass
+
+
+class OperationTests(OperationTestBase):
+ """
+ Tests running the operations and making sure they do what they say they do.
+ Each test looks at their state changing, and then their database operation -
+ both forwards and backwards.
+ """
+
+ def test_create_model(self):
+ """
+ Tests the CreateModel operation.
+ Most other tests use this operation as part of setup, so check failures
+ here first.
+ """
+ operation = migrations.CreateModel(
+ "Pony",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ("pink", models.IntegerField(default=1)),
+ ],
+ )
+ self.assertEqual(operation.describe(), "Create model Pony")
+ self.assertEqual(operation.migration_name_fragment, "pony")
+ # Test the state alteration
+ project_state = ProjectState()
+ new_state = project_state.clone()
+ operation.state_forwards("test_crmo", new_state)
+ self.assertEqual(new_state.models["test_crmo", "pony"].name, "Pony")
+ self.assertEqual(len(new_state.models["test_crmo", "pony"].fields), 2)
+ # Test the database alteration
+ self.assertTableNotExists("test_crmo_pony")
+ with connection.schema_editor() as editor:
+ operation.database_forwards("test_crmo", editor, project_state, new_state)
+ self.assertTableExists("test_crmo_pony")
+ # And test reversal
+ with connection.schema_editor() as editor:
+ operation.database_backwards("test_crmo", editor, new_state, project_state)
+ self.assertTableNotExists("test_crmo_pony")
+ # And deconstruction
+ definition = operation.deconstruct()
+ self.assertEqual(definition[0], "CreateModel")
+ self.assertEqual(definition[1], [])
+ self.assertEqual(sorted(definition[2]), ["fields", "name"])
+ # And default manager not in set
+ operation = migrations.CreateModel(
+ "Foo", fields=[], managers=[("objects", models.Manager())]
+ )
+ definition = operation.deconstruct()
+ self.assertNotIn("managers", definition[2])
+
+ def test_create_model_with_duplicate_field_name(self):
+ with self.assertRaisesMessage(
+ ValueError, "Found duplicate value pink in CreateModel fields argument."
+ ):
+ migrations.CreateModel(
+ "Pony",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ("pink", models.TextField()),
+ ("pink", models.IntegerField(default=1)),
+ ],
+ )
+
+ def test_create_model_with_duplicate_base(self):
+ message = "Found duplicate value test_crmo.pony in CreateModel bases argument."
+ with self.assertRaisesMessage(ValueError, message):
+ migrations.CreateModel(
+ "Pony",
+ fields=[],
+ bases=(
+ "test_crmo.Pony",
+ "test_crmo.Pony",
+ ),
+ )
+ with self.assertRaisesMessage(ValueError, message):
+ migrations.CreateModel(
+ "Pony",
+ fields=[],
+ bases=(
+ "test_crmo.Pony",
+ "test_crmo.pony",
+ ),
+ )
+ message = (
+ "Found duplicate value migrations.unicodemodel in CreateModel bases "
+ "argument."
+ )
+ with self.assertRaisesMessage(ValueError, message):
+ migrations.CreateModel(
+ "Pony",
+ fields=[],
+ bases=(
+ UnicodeModel,
+ UnicodeModel,
+ ),
+ )
+ with self.assertRaisesMessage(ValueError, message):
+ migrations.CreateModel(
+ "Pony",
+ fields=[],
+ bases=(
+ UnicodeModel,
+ "migrations.unicodemodel",
+ ),
+ )
+ with self.assertRaisesMessage(ValueError, message):
+ migrations.CreateModel(
+ "Pony",
+ fields=[],
+ bases=(
+ UnicodeModel,
+ "migrations.UnicodeModel",
+ ),
+ )
+ message = (
+ "Found duplicate value in "
+ "CreateModel bases argument."
+ )
+ with self.assertRaisesMessage(ValueError, message):
+ migrations.CreateModel(
+ "Pony",
+ fields=[],
+ bases=(
+ models.Model,
+ models.Model,
+ ),
+ )
+ message = (
+ "Found duplicate value in "
+ "CreateModel bases argument."
+ )
+ with self.assertRaisesMessage(ValueError, message):
+ migrations.CreateModel(
+ "Pony",
+ fields=[],
+ bases=(
+ Mixin,
+ Mixin,
+ ),
+ )
+
+ def test_create_model_with_duplicate_manager_name(self):
+ with self.assertRaisesMessage(
+ ValueError,
+ "Found duplicate value objects in CreateModel managers argument.",
+ ):
+ migrations.CreateModel(
+ "Pony",
+ fields=[],
+ managers=[
+ ("objects", models.Manager()),
+ ("objects", models.Manager()),
+ ],
+ )
+
+ def test_create_model_with_unique_after(self):
+ """
+ Tests the CreateModel operation directly followed by an
+ AlterUniqueTogether (bug #22844 - sqlite remake issues)
+ """
+ operation1 = migrations.CreateModel(
+ "Pony",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ("pink", models.IntegerField(default=1)),
+ ],
+ )
+ operation2 = migrations.CreateModel(
+ "Rider",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ("number", models.IntegerField(default=1)),
+ ("pony", models.ForeignKey("test_crmoua.Pony", models.CASCADE)),
+ ],
+ )
+ operation3 = migrations.AlterUniqueTogether(
+ "Rider",
+ [
+ ("number", "pony"),
+ ],
+ )
+ # Test the database alteration
+ project_state = ProjectState()
+ self.assertTableNotExists("test_crmoua_pony")
+ self.assertTableNotExists("test_crmoua_rider")
+ with connection.schema_editor() as editor:
+ new_state = project_state.clone()
+ operation1.state_forwards("test_crmoua", new_state)
+ operation1.database_forwards(
+ "test_crmoua", editor, project_state, new_state
+ )
+ project_state, new_state = new_state, new_state.clone()
+ operation2.state_forwards("test_crmoua", new_state)
+ operation2.database_forwards(
+ "test_crmoua", editor, project_state, new_state
+ )
+ project_state, new_state = new_state, new_state.clone()
+ operation3.state_forwards("test_crmoua", new_state)
+ operation3.database_forwards(
+ "test_crmoua", editor, project_state, new_state
+ )
+ self.assertTableExists("test_crmoua_pony")
+ self.assertTableExists("test_crmoua_rider")
+
+ def test_create_model_m2m(self):
+ """
+ Test the creation of a model with a ManyToMany field and the
+ auto-created "through" model.
+ """
+ project_state = self.set_up_test_model("test_crmomm")
+ operation = migrations.CreateModel(
+ "Stable",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ("ponies", models.ManyToManyField("Pony", related_name="stables")),
+ ],
+ )
+ # Test the state alteration
+ new_state = project_state.clone()
+ operation.state_forwards("test_crmomm", new_state)
+ # Test the database alteration
+ self.assertTableNotExists("test_crmomm_stable_ponies")
+ with connection.schema_editor() as editor:
+ operation.database_forwards("test_crmomm", editor, project_state, new_state)
+ self.assertTableExists("test_crmomm_stable")
+ self.assertTableExists("test_crmomm_stable_ponies")
+ self.assertColumnNotExists("test_crmomm_stable", "ponies")
+ # Make sure the M2M field actually works
+ with atomic():
+ Pony = new_state.apps.get_model("test_crmomm", "Pony")
+ Stable = new_state.apps.get_model("test_crmomm", "Stable")
+ stable = Stable.objects.create()
+ p1 = Pony.objects.create(pink=False, weight=4.55)
+ p2 = Pony.objects.create(pink=True, weight=5.43)
+ stable.ponies.add(p1, p2)
+ self.assertEqual(stable.ponies.count(), 2)
+ stable.ponies.all().delete()
+ # And test reversal
+ with connection.schema_editor() as editor:
+ operation.database_backwards(
+ "test_crmomm", editor, new_state, project_state
+ )
+ self.assertTableNotExists("test_crmomm_stable")
+ self.assertTableNotExists("test_crmomm_stable_ponies")
+
+ @skipUnlessDBFeature("supports_collation_on_charfield", "supports_foreign_keys")
+ def test_create_fk_models_to_pk_field_db_collation(self):
+ """Creation of models with a FK to a PK with db_collation."""
+ collation = connection.features.test_collations.get("non_default")
+ if not collation:
+ self.skipTest("Language collations are not supported.")
+
+ app_label = "test_cfkmtopkfdbc"
+ operations = [
+ migrations.CreateModel(
+ "Pony",
+ [
+ (
+ "id",
+ models.CharField(
+ primary_key=True,
+ max_length=10,
+ db_collation=collation,
+ ),
+ ),
+ ],
+ )
+ ]
+ project_state = self.apply_operations(app_label, ProjectState(), operations)
+ # ForeignKey.
+ new_state = project_state.clone()
+ operation = migrations.CreateModel(
+ "Rider",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ("pony", models.ForeignKey("Pony", models.CASCADE)),
+ ],
+ )
+ operation.state_forwards(app_label, new_state)
+ with connection.schema_editor() as editor:
+ operation.database_forwards(app_label, editor, project_state, new_state)
+ self.assertColumnCollation(f"{app_label}_rider", "pony_id", collation)
+ # Reversal.
+ with connection.schema_editor() as editor:
+ operation.database_backwards(app_label, editor, new_state, project_state)
+ # OneToOneField.
+ new_state = project_state.clone()
+ operation = migrations.CreateModel(
+ "ShetlandPony",
+ [
+ (
+ "pony",
+ models.OneToOneField("Pony", models.CASCADE, primary_key=True),
+ ),
+ ("cuteness", models.IntegerField(default=1)),
+ ],
+ )
+ operation.state_forwards(app_label, new_state)
+ with connection.schema_editor() as editor:
+ operation.database_forwards(app_label, editor, project_state, new_state)
+ self.assertColumnCollation(f"{app_label}_shetlandpony", "pony_id", collation)
+ # Reversal.
+ with connection.schema_editor() as editor:
+ operation.database_backwards(app_label, editor, new_state, project_state)
+
+ def test_create_model_inheritance(self):
+ """
+ Tests the CreateModel operation on a multi-table inheritance setup.
+ """
+ project_state = self.set_up_test_model("test_crmoih")
+ # Test the state alteration
+ operation = migrations.CreateModel(
+ "ShetlandPony",
+ [
+ (
+ "pony_ptr",
+ models.OneToOneField(
+ "test_crmoih.Pony",
+ models.CASCADE,
+ auto_created=True,
+ primary_key=True,
+ to_field="id",
+ serialize=False,
+ ),
+ ),
+ ("cuteness", models.IntegerField(default=1)),
+ ],
+ )
+ new_state = project_state.clone()
+ operation.state_forwards("test_crmoih", new_state)
+ self.assertIn(("test_crmoih", "shetlandpony"), new_state.models)
+ # Test the database alteration
+ self.assertTableNotExists("test_crmoih_shetlandpony")
+ with connection.schema_editor() as editor:
+ operation.database_forwards("test_crmoih", editor, project_state, new_state)
+ self.assertTableExists("test_crmoih_shetlandpony")
+ # And test reversal
+ with connection.schema_editor() as editor:
+ operation.database_backwards(
+ "test_crmoih", editor, new_state, project_state
+ )
+ self.assertTableNotExists("test_crmoih_shetlandpony")
+
+ def test_create_proxy_model(self):
+ """
+ CreateModel ignores proxy models.
+ """
+ project_state = self.set_up_test_model("test_crprmo")
+ # Test the state alteration
+ operation = migrations.CreateModel(
+ "ProxyPony",
+ [],
+ options={"proxy": True},
+ bases=("test_crprmo.Pony",),
+ )
+ self.assertEqual(operation.describe(), "Create proxy model ProxyPony")
+ new_state = project_state.clone()
+ operation.state_forwards("test_crprmo", new_state)
+ self.assertIn(("test_crprmo", "proxypony"), new_state.models)
+ # Test the database alteration
+ self.assertTableNotExists("test_crprmo_proxypony")
+ self.assertTableExists("test_crprmo_pony")
+ with connection.schema_editor() as editor:
+ operation.database_forwards("test_crprmo", editor, project_state, new_state)
+ self.assertTableNotExists("test_crprmo_proxypony")
+ self.assertTableExists("test_crprmo_pony")
+ # And test reversal
+ with connection.schema_editor() as editor:
+ operation.database_backwards(
+ "test_crprmo", editor, new_state, project_state
+ )
+ self.assertTableNotExists("test_crprmo_proxypony")
+ self.assertTableExists("test_crprmo_pony")
+ # And deconstruction
+ definition = operation.deconstruct()
+ self.assertEqual(definition[0], "CreateModel")
+ self.assertEqual(definition[1], [])
+ self.assertEqual(sorted(definition[2]), ["bases", "fields", "name", "options"])
+
+ def test_create_unmanaged_model(self):
+ """
+ CreateModel ignores unmanaged models.
+ """
+ project_state = self.set_up_test_model("test_crummo")
+ # Test the state alteration
+ operation = migrations.CreateModel(
+ "UnmanagedPony",
+ [],
+ options={"proxy": True},
+ bases=("test_crummo.Pony",),
+ )
+ self.assertEqual(operation.describe(), "Create proxy model UnmanagedPony")
+ new_state = project_state.clone()
+ operation.state_forwards("test_crummo", new_state)
+ self.assertIn(("test_crummo", "unmanagedpony"), new_state.models)
+ # Test the database alteration
+ self.assertTableNotExists("test_crummo_unmanagedpony")
+ self.assertTableExists("test_crummo_pony")
+ with connection.schema_editor() as editor:
+ operation.database_forwards("test_crummo", editor, project_state, new_state)
+ self.assertTableNotExists("test_crummo_unmanagedpony")
+ self.assertTableExists("test_crummo_pony")
+ # And test reversal
+ with connection.schema_editor() as editor:
+ operation.database_backwards(
+ "test_crummo", editor, new_state, project_state
+ )
+ self.assertTableNotExists("test_crummo_unmanagedpony")
+ self.assertTableExists("test_crummo_pony")
+
+ @skipUnlessDBFeature("supports_table_check_constraints")
+ def test_create_model_with_constraint(self):
+ where = models.Q(pink__gt=2)
+ check_constraint = models.CheckConstraint(
+ check=where, name="test_constraint_pony_pink_gt_2"
+ )
+ operation = migrations.CreateModel(
+ "Pony",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ("pink", models.IntegerField(default=3)),
+ ],
+ options={"constraints": [check_constraint]},
+ )
+
+ # Test the state alteration
+ project_state = ProjectState()
+ new_state = project_state.clone()
+ operation.state_forwards("test_crmo", new_state)
+ self.assertEqual(
+ len(new_state.models["test_crmo", "pony"].options["constraints"]), 1
+ )
+
+ # Test database alteration
+ self.assertTableNotExists("test_crmo_pony")
+ with connection.schema_editor() as editor:
+ operation.database_forwards("test_crmo", editor, project_state, new_state)
+ self.assertTableExists("test_crmo_pony")
+ with connection.cursor() as cursor:
+ with self.assertRaises(IntegrityError):
+ cursor.execute("INSERT INTO test_crmo_pony (id, pink) VALUES (1, 1)")
+
+ # Test reversal
+ with connection.schema_editor() as editor:
+ operation.database_backwards("test_crmo", editor, new_state, project_state)
+ self.assertTableNotExists("test_crmo_pony")
+
+ # Test deconstruction
+ definition = operation.deconstruct()
+ self.assertEqual(definition[0], "CreateModel")
+ self.assertEqual(definition[1], [])
+ self.assertEqual(definition[2]["options"]["constraints"], [check_constraint])
+
+ @skipUnlessDBFeature("supports_table_check_constraints")
+ def test_create_model_with_boolean_expression_in_check_constraint(self):
+ app_label = "test_crmobechc"
+ rawsql_constraint = models.CheckConstraint(
+ check=models.expressions.RawSQL(
+ "price < %s", (1000,), output_field=models.BooleanField()
+ ),
+ name=f"{app_label}_price_lt_1000_raw",
+ )
+ wrapper_constraint = models.CheckConstraint(
+ check=models.expressions.ExpressionWrapper(
+ models.Q(price__gt=500) | models.Q(price__lt=500),
+ output_field=models.BooleanField(),
+ ),
+ name=f"{app_label}_price_neq_500_wrap",
+ )
+ operation = migrations.CreateModel(
+ "Product",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ("price", models.IntegerField(null=True)),
+ ],
+ options={"constraints": [rawsql_constraint, wrapper_constraint]},
+ )
+
+ project_state = ProjectState()
+ new_state = project_state.clone()
+ operation.state_forwards(app_label, new_state)
+ # Add table.
+ self.assertTableNotExists(app_label)
+ with connection.schema_editor() as editor:
+ operation.database_forwards(app_label, editor, project_state, new_state)
+ self.assertTableExists(f"{app_label}_product")
+ insert_sql = f"INSERT INTO {app_label}_product (id, price) VALUES (%d, %d)"
+ with connection.cursor() as cursor:
+ with self.assertRaises(IntegrityError):
+ cursor.execute(insert_sql % (1, 1000))
+ cursor.execute(insert_sql % (1, 999))
+ with self.assertRaises(IntegrityError):
+ cursor.execute(insert_sql % (2, 500))
+ cursor.execute(insert_sql % (2, 499))
+
+ def test_create_model_with_partial_unique_constraint(self):
+ partial_unique_constraint = models.UniqueConstraint(
+ fields=["pink"],
+ condition=models.Q(weight__gt=5),
+ name="test_constraint_pony_pink_for_weight_gt_5_uniq",
+ )
+ operation = migrations.CreateModel(
+ "Pony",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ("pink", models.IntegerField(default=3)),
+ ("weight", models.FloatField()),
+ ],
+ options={"constraints": [partial_unique_constraint]},
+ )
+ # Test the state alteration
+ project_state = ProjectState()
+ new_state = project_state.clone()
+ operation.state_forwards("test_crmo", new_state)
+ self.assertEqual(
+ len(new_state.models["test_crmo", "pony"].options["constraints"]), 1
+ )
+ # Test database alteration
+ self.assertTableNotExists("test_crmo_pony")
+ with connection.schema_editor() as editor:
+ operation.database_forwards("test_crmo", editor, project_state, new_state)
+ self.assertTableExists("test_crmo_pony")
+ # Test constraint works
+ Pony = new_state.apps.get_model("test_crmo", "Pony")
+ Pony.objects.create(pink=1, weight=4.0)
+ Pony.objects.create(pink=1, weight=4.0)
+ Pony.objects.create(pink=1, weight=6.0)
+ if connection.features.supports_partial_indexes:
+ with self.assertRaises(IntegrityError):
+ Pony.objects.create(pink=1, weight=7.0)
+ else:
+ Pony.objects.create(pink=1, weight=7.0)
+ # Test reversal
+ with connection.schema_editor() as editor:
+ operation.database_backwards("test_crmo", editor, new_state, project_state)
+ self.assertTableNotExists("test_crmo_pony")
+ # Test deconstruction
+ definition = operation.deconstruct()
+ self.assertEqual(definition[0], "CreateModel")
+ self.assertEqual(definition[1], [])
+ self.assertEqual(
+ definition[2]["options"]["constraints"], [partial_unique_constraint]
+ )
+
+ def test_create_model_with_deferred_unique_constraint(self):
+ deferred_unique_constraint = models.UniqueConstraint(
+ fields=["pink"],
+ name="deferrable_pink_constraint",
+ deferrable=models.Deferrable.DEFERRED,
+ )
+ operation = migrations.CreateModel(
+ "Pony",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ("pink", models.IntegerField(default=3)),
+ ],
+ options={"constraints": [deferred_unique_constraint]},
+ )
+ project_state = ProjectState()
+ new_state = project_state.clone()
+ operation.state_forwards("test_crmo", new_state)
+ self.assertEqual(
+ len(new_state.models["test_crmo", "pony"].options["constraints"]), 1
+ )
+ self.assertTableNotExists("test_crmo_pony")
+ # Create table.
+ with connection.schema_editor() as editor:
+ operation.database_forwards("test_crmo", editor, project_state, new_state)
+ self.assertTableExists("test_crmo_pony")
+ Pony = new_state.apps.get_model("test_crmo", "Pony")
+ Pony.objects.create(pink=1)
+ if connection.features.supports_deferrable_unique_constraints:
+ # Unique constraint is deferred.
+ with transaction.atomic():
+ obj = Pony.objects.create(pink=1)
+ obj.pink = 2
+ obj.save()
+ # Constraint behavior can be changed with SET CONSTRAINTS.
+ with self.assertRaises(IntegrityError):
+ with transaction.atomic(), connection.cursor() as cursor:
+ quoted_name = connection.ops.quote_name(
+ deferred_unique_constraint.name
+ )
+ cursor.execute("SET CONSTRAINTS %s IMMEDIATE" % quoted_name)
+ obj = Pony.objects.create(pink=1)
+ obj.pink = 3
+ obj.save()
+ else:
+ Pony.objects.create(pink=1)
+ # Reversal.
+ with connection.schema_editor() as editor:
+ operation.database_backwards("test_crmo", editor, new_state, project_state)
+ self.assertTableNotExists("test_crmo_pony")
+ # Deconstruction.
+ definition = operation.deconstruct()
+ self.assertEqual(definition[0], "CreateModel")
+ self.assertEqual(definition[1], [])
+ self.assertEqual(
+ definition[2]["options"]["constraints"],
+ [deferred_unique_constraint],
+ )
+
+ @skipUnlessDBFeature("supports_covering_indexes")
+ def test_create_model_with_covering_unique_constraint(self):
+ covering_unique_constraint = models.UniqueConstraint(
+ fields=["pink"],
+ include=["weight"],
+ name="test_constraint_pony_pink_covering_weight",
+ )
+ operation = migrations.CreateModel(
+ "Pony",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ("pink", models.IntegerField(default=3)),
+ ("weight", models.FloatField()),
+ ],
+ options={"constraints": [covering_unique_constraint]},
+ )
+ project_state = ProjectState()
+ new_state = project_state.clone()
+ operation.state_forwards("test_crmo", new_state)
+ self.assertEqual(
+ len(new_state.models["test_crmo", "pony"].options["constraints"]), 1
+ )
+ self.assertTableNotExists("test_crmo_pony")
+ # Create table.
+ with connection.schema_editor() as editor:
+ operation.database_forwards("test_crmo", editor, project_state, new_state)
+ self.assertTableExists("test_crmo_pony")
+ Pony = new_state.apps.get_model("test_crmo", "Pony")
+ Pony.objects.create(pink=1, weight=4.0)
+ with self.assertRaises(IntegrityError):
+ Pony.objects.create(pink=1, weight=7.0)
+ # Reversal.
+ with connection.schema_editor() as editor:
+ operation.database_backwards("test_crmo", editor, new_state, project_state)
+ self.assertTableNotExists("test_crmo_pony")
+ # Deconstruction.
+ definition = operation.deconstruct()
+ self.assertEqual(definition[0], "CreateModel")
+ self.assertEqual(definition[1], [])
+ self.assertEqual(
+ definition[2]["options"]["constraints"],
+ [covering_unique_constraint],
+ )
+
+ def test_create_model_managers(self):
+ """
+ The managers on a model are set.
+ """
+ project_state = self.set_up_test_model("test_cmoma")
+ # Test the state alteration
+ operation = migrations.CreateModel(
+ "Food",
+ fields=[
+ ("id", models.AutoField(primary_key=True)),
+ ],
+ managers=[
+ ("food_qs", FoodQuerySet.as_manager()),
+ ("food_mgr", FoodManager("a", "b")),
+ ("food_mgr_kwargs", FoodManager("x", "y", 3, 4)),
+ ],
+ )
+ self.assertEqual(operation.describe(), "Create model Food")
+ new_state = project_state.clone()
+ operation.state_forwards("test_cmoma", new_state)
+ self.assertIn(("test_cmoma", "food"), new_state.models)
+ managers = new_state.models["test_cmoma", "food"].managers
+ self.assertEqual(managers[0][0], "food_qs")
+ self.assertIsInstance(managers[0][1], models.Manager)
+ self.assertEqual(managers[1][0], "food_mgr")
+ self.assertIsInstance(managers[1][1], FoodManager)
+ self.assertEqual(managers[1][1].args, ("a", "b", 1, 2))
+ self.assertEqual(managers[2][0], "food_mgr_kwargs")
+ self.assertIsInstance(managers[2][1], FoodManager)
+ self.assertEqual(managers[2][1].args, ("x", "y", 3, 4))
+
+ def test_delete_model(self):
+ """
+ Tests the DeleteModel operation.
+ """
+ project_state = self.set_up_test_model("test_dlmo")
+ # Test the state alteration
+ operation = migrations.DeleteModel("Pony")
+ self.assertEqual(operation.describe(), "Delete model Pony")
+ self.assertEqual(operation.migration_name_fragment, "delete_pony")
+ new_state = project_state.clone()
+ operation.state_forwards("test_dlmo", new_state)
+ self.assertNotIn(("test_dlmo", "pony"), new_state.models)
+ # Test the database alteration
+ self.assertTableExists("test_dlmo_pony")
+ with connection.schema_editor() as editor:
+ operation.database_forwards("test_dlmo", editor, project_state, new_state)
+ self.assertTableNotExists("test_dlmo_pony")
+ # And test reversal
+ with connection.schema_editor() as editor:
+ operation.database_backwards("test_dlmo", editor, new_state, project_state)
+ self.assertTableExists("test_dlmo_pony")
+ # And deconstruction
+ definition = operation.deconstruct()
+ self.assertEqual(definition[0], "DeleteModel")
+ self.assertEqual(definition[1], [])
+ self.assertEqual(list(definition[2]), ["name"])
+
+ def test_delete_proxy_model(self):
+ """
+ Tests the DeleteModel operation ignores proxy models.
+ """
+ project_state = self.set_up_test_model("test_dlprmo", proxy_model=True)
+ # Test the state alteration
+ operation = migrations.DeleteModel("ProxyPony")
+ new_state = project_state.clone()
+ operation.state_forwards("test_dlprmo", new_state)
+ self.assertIn(("test_dlprmo", "proxypony"), project_state.models)
+ self.assertNotIn(("test_dlprmo", "proxypony"), new_state.models)
+ # Test the database alteration
+ self.assertTableExists("test_dlprmo_pony")
+ self.assertTableNotExists("test_dlprmo_proxypony")
+ with connection.schema_editor() as editor:
+ operation.database_forwards("test_dlprmo", editor, project_state, new_state)
+ self.assertTableExists("test_dlprmo_pony")
+ self.assertTableNotExists("test_dlprmo_proxypony")
+ # And test reversal
+ with connection.schema_editor() as editor:
+ operation.database_backwards(
+ "test_dlprmo", editor, new_state, project_state
+ )
+ self.assertTableExists("test_dlprmo_pony")
+ self.assertTableNotExists("test_dlprmo_proxypony")
+
+ def test_delete_mti_model(self):
+ project_state = self.set_up_test_model("test_dlmtimo", mti_model=True)
+ # Test the state alteration
+ operation = migrations.DeleteModel("ShetlandPony")
+ new_state = project_state.clone()
+ operation.state_forwards("test_dlmtimo", new_state)
+ self.assertIn(("test_dlmtimo", "shetlandpony"), project_state.models)
+ self.assertNotIn(("test_dlmtimo", "shetlandpony"), new_state.models)
+ # Test the database alteration
+ self.assertTableExists("test_dlmtimo_pony")
+ self.assertTableExists("test_dlmtimo_shetlandpony")
+ self.assertColumnExists("test_dlmtimo_shetlandpony", "pony_ptr_id")
+ with connection.schema_editor() as editor:
+ operation.database_forwards(
+ "test_dlmtimo", editor, project_state, new_state
+ )
+ self.assertTableExists("test_dlmtimo_pony")
+ self.assertTableNotExists("test_dlmtimo_shetlandpony")
+ # And test reversal
+ with connection.schema_editor() as editor:
+ operation.database_backwards(
+ "test_dlmtimo", editor, new_state, project_state
+ )
+ self.assertTableExists("test_dlmtimo_pony")
+ self.assertTableExists("test_dlmtimo_shetlandpony")
+ self.assertColumnExists("test_dlmtimo_shetlandpony", "pony_ptr_id")
+
+ def test_rename_model(self):
+ """
+ Tests the RenameModel operation.
+ """
+ project_state = self.set_up_test_model("test_rnmo", related_model=True)
+ # Test the state alteration
+ operation = migrations.RenameModel("Pony", "Horse")
+ self.assertEqual(operation.describe(), "Rename model Pony to Horse")
+ self.assertEqual(operation.migration_name_fragment, "rename_pony_horse")
+ # Test initial state and database
+ self.assertIn(("test_rnmo", "pony"), project_state.models)
+ self.assertNotIn(("test_rnmo", "horse"), project_state.models)
+ self.assertTableExists("test_rnmo_pony")
+ self.assertTableNotExists("test_rnmo_horse")
+ if connection.features.supports_foreign_keys:
+ self.assertFKExists(
+ "test_rnmo_rider", ["pony_id"], ("test_rnmo_pony", "id")
+ )
+ self.assertFKNotExists(
+ "test_rnmo_rider", ["pony_id"], ("test_rnmo_horse", "id")
+ )
+ # Migrate forwards
+ new_state = project_state.clone()
+ atomic_rename = connection.features.supports_atomic_references_rename
+ new_state = self.apply_operations(
+ "test_rnmo", new_state, [operation], atomic=atomic_rename
+ )
+ # Test new state and database
+ self.assertNotIn(("test_rnmo", "pony"), new_state.models)
+ self.assertIn(("test_rnmo", "horse"), new_state.models)
+ # RenameModel also repoints all incoming FKs and M2Ms
+ self.assertEqual(
+ new_state.models["test_rnmo", "rider"].fields["pony"].remote_field.model,
+ "test_rnmo.Horse",
+ )
+ self.assertTableNotExists("test_rnmo_pony")
+ self.assertTableExists("test_rnmo_horse")
+ if connection.features.supports_foreign_keys:
+ self.assertFKNotExists(
+ "test_rnmo_rider", ["pony_id"], ("test_rnmo_pony", "id")
+ )
+ self.assertFKExists(
+ "test_rnmo_rider", ["pony_id"], ("test_rnmo_horse", "id")
+ )
+ # Migrate backwards
+ original_state = self.unapply_operations(
+ "test_rnmo", project_state, [operation], atomic=atomic_rename
+ )
+ # Test original state and database
+ self.assertIn(("test_rnmo", "pony"), original_state.models)
+ self.assertNotIn(("test_rnmo", "horse"), original_state.models)
+ self.assertEqual(
+ original_state.models["test_rnmo", "rider"]
+ .fields["pony"]
+ .remote_field.model,
+ "Pony",
+ )
+ self.assertTableExists("test_rnmo_pony")
+ self.assertTableNotExists("test_rnmo_horse")
+ if connection.features.supports_foreign_keys:
+ self.assertFKExists(
+ "test_rnmo_rider", ["pony_id"], ("test_rnmo_pony", "id")
+ )
+ self.assertFKNotExists(
+ "test_rnmo_rider", ["pony_id"], ("test_rnmo_horse", "id")
+ )
+ # And deconstruction
+ definition = operation.deconstruct()
+ self.assertEqual(definition[0], "RenameModel")
+ self.assertEqual(definition[1], [])
+ self.assertEqual(definition[2], {"old_name": "Pony", "new_name": "Horse"})
+
+ def test_rename_model_state_forwards(self):
+ """
+ RenameModel operations shouldn't trigger the caching of rendered apps
+ on state without prior apps.
+ """
+ state = ProjectState()
+ state.add_model(ModelState("migrations", "Foo", []))
+ operation = migrations.RenameModel("Foo", "Bar")
+ operation.state_forwards("migrations", state)
+ self.assertNotIn("apps", state.__dict__)
+ self.assertNotIn(("migrations", "foo"), state.models)
+ self.assertIn(("migrations", "bar"), state.models)
+ # Now with apps cached.
+ apps = state.apps
+ operation = migrations.RenameModel("Bar", "Foo")
+ operation.state_forwards("migrations", state)
+ self.assertIs(state.apps, apps)
+ self.assertNotIn(("migrations", "bar"), state.models)
+ self.assertIn(("migrations", "foo"), state.models)
+
+ def test_rename_model_with_self_referential_fk(self):
+ """
+ Tests the RenameModel operation on model with self referential FK.
+ """
+ project_state = self.set_up_test_model("test_rmwsrf", related_model=True)
+ # Test the state alteration
+ operation = migrations.RenameModel("Rider", "HorseRider")
+ self.assertEqual(operation.describe(), "Rename model Rider to HorseRider")
+ new_state = project_state.clone()
+ operation.state_forwards("test_rmwsrf", new_state)
+ self.assertNotIn(("test_rmwsrf", "rider"), new_state.models)
+ self.assertIn(("test_rmwsrf", "horserider"), new_state.models)
+ # Remember, RenameModel also repoints all incoming FKs and M2Ms
+ self.assertEqual(
+ "self",
+ new_state.models["test_rmwsrf", "horserider"]
+ .fields["friend"]
+ .remote_field.model,
+ )
+ HorseRider = new_state.apps.get_model("test_rmwsrf", "horserider")
+ self.assertIs(
+ HorseRider._meta.get_field("horserider").remote_field.model, HorseRider
+ )
+ # Test the database alteration
+ self.assertTableExists("test_rmwsrf_rider")
+ self.assertTableNotExists("test_rmwsrf_horserider")
+ if connection.features.supports_foreign_keys:
+ self.assertFKExists(
+ "test_rmwsrf_rider", ["friend_id"], ("test_rmwsrf_rider", "id")
+ )
+ self.assertFKNotExists(
+ "test_rmwsrf_rider", ["friend_id"], ("test_rmwsrf_horserider", "id")
+ )
+ atomic_rename = connection.features.supports_atomic_references_rename
+ with connection.schema_editor(atomic=atomic_rename) as editor:
+ operation.database_forwards("test_rmwsrf", editor, project_state, new_state)
+ self.assertTableNotExists("test_rmwsrf_rider")
+ self.assertTableExists("test_rmwsrf_horserider")
+ if connection.features.supports_foreign_keys:
+ self.assertFKNotExists(
+ "test_rmwsrf_horserider", ["friend_id"], ("test_rmwsrf_rider", "id")
+ )
+ self.assertFKExists(
+ "test_rmwsrf_horserider",
+ ["friend_id"],
+ ("test_rmwsrf_horserider", "id"),
+ )
+ # And test reversal
+ with connection.schema_editor(atomic=atomic_rename) as editor:
+ operation.database_backwards(
+ "test_rmwsrf", editor, new_state, project_state
+ )
+ self.assertTableExists("test_rmwsrf_rider")
+ self.assertTableNotExists("test_rmwsrf_horserider")
+ if connection.features.supports_foreign_keys:
+ self.assertFKExists(
+ "test_rmwsrf_rider", ["friend_id"], ("test_rmwsrf_rider", "id")
+ )
+ self.assertFKNotExists(
+ "test_rmwsrf_rider", ["friend_id"], ("test_rmwsrf_horserider", "id")
+ )
+
+ def test_rename_model_with_superclass_fk(self):
+ """
+ Tests the RenameModel operation on a model which has a superclass that
+ has a foreign key.
+ """
+ project_state = self.set_up_test_model(
+ "test_rmwsc", related_model=True, mti_model=True
+ )
+ # Test the state alteration
+ operation = migrations.RenameModel("ShetlandPony", "LittleHorse")
+ self.assertEqual(
+ operation.describe(), "Rename model ShetlandPony to LittleHorse"
+ )
+ new_state = project_state.clone()
+ operation.state_forwards("test_rmwsc", new_state)
+ self.assertNotIn(("test_rmwsc", "shetlandpony"), new_state.models)
+ self.assertIn(("test_rmwsc", "littlehorse"), new_state.models)
+ # RenameModel shouldn't repoint the superclass's relations, only local ones
+ self.assertEqual(
+ project_state.models["test_rmwsc", "rider"]
+ .fields["pony"]
+ .remote_field.model,
+ new_state.models["test_rmwsc", "rider"].fields["pony"].remote_field.model,
+ )
+ # Before running the migration we have a table for Shetland Pony, not
+ # Little Horse.
+ self.assertTableExists("test_rmwsc_shetlandpony")
+ self.assertTableNotExists("test_rmwsc_littlehorse")
+ if connection.features.supports_foreign_keys:
+ # and the foreign key on rider points to pony, not shetland pony
+ self.assertFKExists(
+ "test_rmwsc_rider", ["pony_id"], ("test_rmwsc_pony", "id")
+ )
+ self.assertFKNotExists(
+ "test_rmwsc_rider", ["pony_id"], ("test_rmwsc_shetlandpony", "id")
+ )
+ with connection.schema_editor(
+ atomic=connection.features.supports_atomic_references_rename
+ ) as editor:
+ operation.database_forwards("test_rmwsc", editor, project_state, new_state)
+ # Now we have a little horse table, not shetland pony
+ self.assertTableNotExists("test_rmwsc_shetlandpony")
+ self.assertTableExists("test_rmwsc_littlehorse")
+ if connection.features.supports_foreign_keys:
+ # but the Foreign keys still point at pony, not little horse
+ self.assertFKExists(
+ "test_rmwsc_rider", ["pony_id"], ("test_rmwsc_pony", "id")
+ )
+ self.assertFKNotExists(
+ "test_rmwsc_rider", ["pony_id"], ("test_rmwsc_littlehorse", "id")
+ )
+
+ def test_rename_model_with_self_referential_m2m(self):
+ app_label = "test_rename_model_with_self_referential_m2m"
+
+ project_state = self.apply_operations(
+ app_label,
+ ProjectState(),
+ operations=[
+ migrations.CreateModel(
+ "ReflexivePony",
+ fields=[
+ ("id", models.AutoField(primary_key=True)),
+ ("ponies", models.ManyToManyField("self")),
+ ],
+ ),
+ ],
+ )
+ project_state = self.apply_operations(
+ app_label,
+ project_state,
+ operations=[
+ migrations.RenameModel("ReflexivePony", "ReflexivePony2"),
+ ],
+ atomic=connection.features.supports_atomic_references_rename,
+ )
+ Pony = project_state.apps.get_model(app_label, "ReflexivePony2")
+ pony = Pony.objects.create()
+ pony.ponies.add(pony)
+
+ def test_rename_model_with_m2m(self):
+ app_label = "test_rename_model_with_m2m"
+ project_state = self.apply_operations(
+ app_label,
+ ProjectState(),
+ operations=[
+ migrations.CreateModel(
+ "Rider",
+ fields=[
+ ("id", models.AutoField(primary_key=True)),
+ ],
+ ),
+ migrations.CreateModel(
+ "Pony",
+ fields=[
+ ("id", models.AutoField(primary_key=True)),
+ ("riders", models.ManyToManyField("Rider")),
+ ],
+ ),
+ ],
+ )
+ Pony = project_state.apps.get_model(app_label, "Pony")
+ Rider = project_state.apps.get_model(app_label, "Rider")
+ pony = Pony.objects.create()
+ rider = Rider.objects.create()
+ pony.riders.add(rider)
+
+ project_state = self.apply_operations(
+ app_label,
+ project_state,
+ operations=[
+ migrations.RenameModel("Pony", "Pony2"),
+ ],
+ atomic=connection.features.supports_atomic_references_rename,
+ )
+ Pony = project_state.apps.get_model(app_label, "Pony2")
+ Rider = project_state.apps.get_model(app_label, "Rider")
+ pony = Pony.objects.create()
+ rider = Rider.objects.create()
+ pony.riders.add(rider)
+ self.assertEqual(Pony.objects.count(), 2)
+ self.assertEqual(Rider.objects.count(), 2)
+ self.assertEqual(
+ Pony._meta.get_field("riders").remote_field.through.objects.count(), 2
+ )
+
+ def test_rename_model_with_m2m_models_in_different_apps_with_same_name(self):
+ app_label_1 = "test_rmw_m2m_1"
+ app_label_2 = "test_rmw_m2m_2"
+ project_state = self.apply_operations(
+ app_label_1,
+ ProjectState(),
+ operations=[
+ migrations.CreateModel(
+ "Rider",
+ fields=[
+ ("id", models.AutoField(primary_key=True)),
+ ],
+ ),
+ ],
+ )
+ project_state = self.apply_operations(
+ app_label_2,
+ project_state,
+ operations=[
+ migrations.CreateModel(
+ "Rider",
+ fields=[
+ ("id", models.AutoField(primary_key=True)),
+ ("riders", models.ManyToManyField(f"{app_label_1}.Rider")),
+ ],
+ ),
+ ],
+ )
+ m2m_table = f"{app_label_2}_rider_riders"
+ self.assertColumnExists(m2m_table, "from_rider_id")
+ self.assertColumnExists(m2m_table, "to_rider_id")
+
+ Rider_1 = project_state.apps.get_model(app_label_1, "Rider")
+ Rider_2 = project_state.apps.get_model(app_label_2, "Rider")
+ rider_2 = Rider_2.objects.create()
+ rider_2.riders.add(Rider_1.objects.create())
+ # Rename model.
+ project_state_2 = project_state.clone()
+ project_state = self.apply_operations(
+ app_label_2,
+ project_state,
+ operations=[migrations.RenameModel("Rider", "Pony")],
+ atomic=connection.features.supports_atomic_references_rename,
+ )
+
+ m2m_table = f"{app_label_2}_pony_riders"
+ self.assertColumnExists(m2m_table, "pony_id")
+ self.assertColumnExists(m2m_table, "rider_id")
+
+ Rider_1 = project_state.apps.get_model(app_label_1, "Rider")
+ Rider_2 = project_state.apps.get_model(app_label_2, "Pony")
+ rider_2 = Rider_2.objects.create()
+ rider_2.riders.add(Rider_1.objects.create())
+ self.assertEqual(Rider_1.objects.count(), 2)
+ self.assertEqual(Rider_2.objects.count(), 2)
+ self.assertEqual(
+ Rider_2._meta.get_field("riders").remote_field.through.objects.count(), 2
+ )
+ # Reversal.
+ self.unapply_operations(
+ app_label_2,
+ project_state_2,
+ operations=[migrations.RenameModel("Rider", "Pony")],
+ atomic=connection.features.supports_atomic_references_rename,
+ )
+ m2m_table = f"{app_label_2}_rider_riders"
+ self.assertColumnExists(m2m_table, "to_rider_id")
+ self.assertColumnExists(m2m_table, "from_rider_id")
+
+ def test_rename_model_with_db_table_rename_m2m(self):
+ app_label = "test_rmwdbrm2m"
+ project_state = self.apply_operations(
+ app_label,
+ ProjectState(),
+ operations=[
+ migrations.CreateModel(
+ "Rider",
+ fields=[
+ ("id", models.AutoField(primary_key=True)),
+ ],
+ ),
+ migrations.CreateModel(
+ "Pony",
+ fields=[
+ ("id", models.AutoField(primary_key=True)),
+ ("riders", models.ManyToManyField("Rider")),
+ ],
+ options={"db_table": "pony"},
+ ),
+ ],
+ )
+ new_state = self.apply_operations(
+ app_label,
+ project_state,
+ operations=[migrations.RenameModel("Pony", "PinkPony")],
+ atomic=connection.features.supports_atomic_references_rename,
+ )
+ Pony = new_state.apps.get_model(app_label, "PinkPony")
+ Rider = new_state.apps.get_model(app_label, "Rider")
+ pony = Pony.objects.create()
+ rider = Rider.objects.create()
+ pony.riders.add(rider)
+
+ def test_rename_m2m_target_model(self):
+ app_label = "test_rename_m2m_target_model"
+ project_state = self.apply_operations(
+ app_label,
+ ProjectState(),
+ operations=[
+ migrations.CreateModel(
+ "Rider",
+ fields=[
+ ("id", models.AutoField(primary_key=True)),
+ ],
+ ),
+ migrations.CreateModel(
+ "Pony",
+ fields=[
+ ("id", models.AutoField(primary_key=True)),
+ ("riders", models.ManyToManyField("Rider")),
+ ],
+ ),
+ ],
+ )
+ Pony = project_state.apps.get_model(app_label, "Pony")
+ Rider = project_state.apps.get_model(app_label, "Rider")
+ pony = Pony.objects.create()
+ rider = Rider.objects.create()
+ pony.riders.add(rider)
+
+ project_state = self.apply_operations(
+ app_label,
+ project_state,
+ operations=[
+ migrations.RenameModel("Rider", "Rider2"),
+ ],
+ atomic=connection.features.supports_atomic_references_rename,
+ )
+ Pony = project_state.apps.get_model(app_label, "Pony")
+ Rider = project_state.apps.get_model(app_label, "Rider2")
+ pony = Pony.objects.create()
+ rider = Rider.objects.create()
+ pony.riders.add(rider)
+ self.assertEqual(Pony.objects.count(), 2)
+ self.assertEqual(Rider.objects.count(), 2)
+ self.assertEqual(
+ Pony._meta.get_field("riders").remote_field.through.objects.count(), 2
+ )
+
+ def test_rename_m2m_through_model(self):
+ app_label = "test_rename_through"
+ project_state = self.apply_operations(
+ app_label,
+ ProjectState(),
+ operations=[
+ migrations.CreateModel(
+ "Rider",
+ fields=[
+ ("id", models.AutoField(primary_key=True)),
+ ],
+ ),
+ migrations.CreateModel(
+ "Pony",
+ fields=[
+ ("id", models.AutoField(primary_key=True)),
+ ],
+ ),
+ migrations.CreateModel(
+ "PonyRider",
+ fields=[
+ ("id", models.AutoField(primary_key=True)),
+ (
+ "rider",
+ models.ForeignKey(
+ "test_rename_through.Rider", models.CASCADE
+ ),
+ ),
+ (
+ "pony",
+ models.ForeignKey(
+ "test_rename_through.Pony", models.CASCADE
+ ),
+ ),
+ ],
+ ),
+ migrations.AddField(
+ "Pony",
+ "riders",
+ models.ManyToManyField(
+ "test_rename_through.Rider",
+ through="test_rename_through.PonyRider",
+ ),
+ ),
+ ],
+ )
+ Pony = project_state.apps.get_model(app_label, "Pony")
+ Rider = project_state.apps.get_model(app_label, "Rider")
+ PonyRider = project_state.apps.get_model(app_label, "PonyRider")
+ pony = Pony.objects.create()
+ rider = Rider.objects.create()
+ PonyRider.objects.create(pony=pony, rider=rider)
+
+ project_state = self.apply_operations(
+ app_label,
+ project_state,
+ operations=[
+ migrations.RenameModel("PonyRider", "PonyRider2"),
+ ],
+ )
+ Pony = project_state.apps.get_model(app_label, "Pony")
+ Rider = project_state.apps.get_model(app_label, "Rider")
+ PonyRider = project_state.apps.get_model(app_label, "PonyRider2")
+ pony = Pony.objects.first()
+ rider = Rider.objects.create()
+ PonyRider.objects.create(pony=pony, rider=rider)
+ self.assertEqual(Pony.objects.count(), 1)
+ self.assertEqual(Rider.objects.count(), 2)
+ self.assertEqual(PonyRider.objects.count(), 2)
+ self.assertEqual(pony.riders.count(), 2)
+
+ def test_rename_m2m_model_after_rename_field(self):
+ """RenameModel renames a many-to-many column after a RenameField."""
+ app_label = "test_rename_multiple"
+ project_state = self.apply_operations(
+ app_label,
+ ProjectState(),
+ operations=[
+ migrations.CreateModel(
+ "Pony",
+ fields=[
+ ("id", models.AutoField(primary_key=True)),
+ ("name", models.CharField(max_length=20)),
+ ],
+ ),
+ migrations.CreateModel(
+ "Rider",
+ fields=[
+ ("id", models.AutoField(primary_key=True)),
+ (
+ "pony",
+ models.ForeignKey(
+ "test_rename_multiple.Pony", models.CASCADE
+ ),
+ ),
+ ],
+ ),
+ migrations.CreateModel(
+ "PonyRider",
+ fields=[
+ ("id", models.AutoField(primary_key=True)),
+ ("riders", models.ManyToManyField("Rider")),
+ ],
+ ),
+ migrations.RenameField(
+ model_name="pony", old_name="name", new_name="fancy_name"
+ ),
+ migrations.RenameModel(old_name="Rider", new_name="Jockey"),
+ ],
+ atomic=connection.features.supports_atomic_references_rename,
+ )
+ Pony = project_state.apps.get_model(app_label, "Pony")
+ Jockey = project_state.apps.get_model(app_label, "Jockey")
+ PonyRider = project_state.apps.get_model(app_label, "PonyRider")
+ # No "no such column" error means the column was renamed correctly.
+ pony = Pony.objects.create(fancy_name="a good name")
+ jockey = Jockey.objects.create(pony=pony)
+ ponyrider = PonyRider.objects.create()
+ ponyrider.riders.add(jockey)
+
+ def test_add_field(self):
+ """
+ Tests the AddField operation.
+ """
+ # Test the state alteration
+ operation = migrations.AddField(
+ "Pony",
+ "height",
+ models.FloatField(null=True, default=5),
+ )
+ self.assertEqual(operation.describe(), "Add field height to Pony")
+ self.assertEqual(operation.migration_name_fragment, "pony_height")
+ project_state, new_state = self.make_test_state("test_adfl", operation)
+ self.assertEqual(len(new_state.models["test_adfl", "pony"].fields), 6)
+ field = new_state.models["test_adfl", "pony"].fields["height"]
+ self.assertEqual(field.default, 5)
+ # Test the database alteration
+ self.assertColumnNotExists("test_adfl_pony", "height")
+ with connection.schema_editor() as editor:
+ operation.database_forwards("test_adfl", editor, project_state, new_state)
+ self.assertColumnExists("test_adfl_pony", "height")
+ # And test reversal
+ with connection.schema_editor() as editor:
+ operation.database_backwards("test_adfl", editor, new_state, project_state)
+ self.assertColumnNotExists("test_adfl_pony", "height")
+ # And deconstruction
+ definition = operation.deconstruct()
+ self.assertEqual(definition[0], "AddField")
+ self.assertEqual(definition[1], [])
+ self.assertEqual(sorted(definition[2]), ["field", "model_name", "name"])
+
+ def test_add_charfield(self):
+ """
+ Tests the AddField operation on TextField.
+ """
+ project_state = self.set_up_test_model("test_adchfl")
+
+ Pony = project_state.apps.get_model("test_adchfl", "Pony")
+ pony = Pony.objects.create(weight=42)
+
+ new_state = self.apply_operations(
+ "test_adchfl",
+ project_state,
+ [
+ migrations.AddField(
+ "Pony",
+ "text",
+ models.CharField(max_length=10, default="some text"),
+ ),
+ migrations.AddField(
+ "Pony",
+ "empty",
+ models.CharField(max_length=10, default=""),
+ ),
+ # If not properly quoted digits would be interpreted as an int.
+ migrations.AddField(
+ "Pony",
+ "digits",
+ models.CharField(max_length=10, default="42"),
+ ),
+ # Manual quoting is fragile and could trip on quotes. Refs #xyz.
+ migrations.AddField(
+ "Pony",
+ "quotes",
+ models.CharField(max_length=10, default='"\'"'),
+ ),
+ ],
+ )
+
+ Pony = new_state.apps.get_model("test_adchfl", "Pony")
+ pony = Pony.objects.get(pk=pony.pk)
+ self.assertEqual(pony.text, "some text")
+ self.assertEqual(pony.empty, "")
+ self.assertEqual(pony.digits, "42")
+ self.assertEqual(pony.quotes, '"\'"')
+
+ def test_add_textfield(self):
+ """
+ Tests the AddField operation on TextField.
+ """
+ project_state = self.set_up_test_model("test_adtxtfl")
+
+ Pony = project_state.apps.get_model("test_adtxtfl", "Pony")
+ pony = Pony.objects.create(weight=42)
+
+ new_state = self.apply_operations(
+ "test_adtxtfl",
+ project_state,
+ [
+ migrations.AddField(
+ "Pony",
+ "text",
+ models.TextField(default="some text"),
+ ),
+ migrations.AddField(
+ "Pony",
+ "empty",
+ models.TextField(default=""),
+ ),
+ # If not properly quoted digits would be interpreted as an int.
+ migrations.AddField(
+ "Pony",
+ "digits",
+ models.TextField(default="42"),
+ ),
+ # Manual quoting is fragile and could trip on quotes. Refs #xyz.
+ migrations.AddField(
+ "Pony",
+ "quotes",
+ models.TextField(default='"\'"'),
+ ),
+ ],
+ )
+
+ Pony = new_state.apps.get_model("test_adtxtfl", "Pony")
+ pony = Pony.objects.get(pk=pony.pk)
+ self.assertEqual(pony.text, "some text")
+ self.assertEqual(pony.empty, "")
+ self.assertEqual(pony.digits, "42")
+ self.assertEqual(pony.quotes, '"\'"')
+
+ def test_add_binaryfield(self):
+ """
+ Tests the AddField operation on TextField/BinaryField.
+ """
+ project_state = self.set_up_test_model("test_adbinfl")
+
+ Pony = project_state.apps.get_model("test_adbinfl", "Pony")
+ pony = Pony.objects.create(weight=42)
+
+ new_state = self.apply_operations(
+ "test_adbinfl",
+ project_state,
+ [
+ migrations.AddField(
+ "Pony",
+ "blob",
+ models.BinaryField(default=b"some text"),
+ ),
+ migrations.AddField(
+ "Pony",
+ "empty",
+ models.BinaryField(default=b""),
+ ),
+ # If not properly quoted digits would be interpreted as an int.
+ migrations.AddField(
+ "Pony",
+ "digits",
+ models.BinaryField(default=b"42"),
+ ),
+ # Manual quoting is fragile and could trip on quotes. Refs #xyz.
+ migrations.AddField(
+ "Pony",
+ "quotes",
+ models.BinaryField(default=b'"\'"'),
+ ),
+ ],
+ )
+
+ Pony = new_state.apps.get_model("test_adbinfl", "Pony")
+ pony = Pony.objects.get(pk=pony.pk)
+ # SQLite returns buffer/memoryview, cast to bytes for checking.
+ self.assertEqual(bytes(pony.blob), b"some text")
+ self.assertEqual(bytes(pony.empty), b"")
+ self.assertEqual(bytes(pony.digits), b"42")
+ self.assertEqual(bytes(pony.quotes), b'"\'"')
+
+ def test_column_name_quoting(self):
+ """
+ Column names that are SQL keywords shouldn't cause problems when used
+ in migrations (#22168).
+ """
+ project_state = self.set_up_test_model("test_regr22168")
+ operation = migrations.AddField(
+ "Pony",
+ "order",
+ models.IntegerField(default=0),
+ )
+ new_state = project_state.clone()
+ operation.state_forwards("test_regr22168", new_state)
+ with connection.schema_editor() as editor:
+ operation.database_forwards(
+ "test_regr22168", editor, project_state, new_state
+ )
+ self.assertColumnExists("test_regr22168_pony", "order")
+
+ def test_add_field_preserve_default(self):
+ """
+ Tests the AddField operation's state alteration
+ when preserve_default = False.
+ """
+ project_state = self.set_up_test_model("test_adflpd")
+ # Test the state alteration
+ operation = migrations.AddField(
+ "Pony",
+ "height",
+ models.FloatField(null=True, default=4),
+ preserve_default=False,
+ )
+ new_state = project_state.clone()
+ operation.state_forwards("test_adflpd", new_state)
+ self.assertEqual(len(new_state.models["test_adflpd", "pony"].fields), 6)
+ field = new_state.models["test_adflpd", "pony"].fields["height"]
+ self.assertEqual(field.default, models.NOT_PROVIDED)
+ # Test the database alteration
+ project_state.apps.get_model("test_adflpd", "pony").objects.create(
+ weight=4,
+ )
+ self.assertColumnNotExists("test_adflpd_pony", "height")
+ with connection.schema_editor() as editor:
+ operation.database_forwards("test_adflpd", editor, project_state, new_state)
+ self.assertColumnExists("test_adflpd_pony", "height")
+ # And deconstruction
+ definition = operation.deconstruct()
+ self.assertEqual(definition[0], "AddField")
+ self.assertEqual(definition[1], [])
+ self.assertEqual(
+ sorted(definition[2]), ["field", "model_name", "name", "preserve_default"]
+ )
+
+ def test_add_field_database_default(self):
+ """The AddField operation can set and unset a database default."""
+ app_label = "test_adfldd"
+ table_name = f"{app_label}_pony"
+ project_state = self.set_up_test_model(app_label)
+ operation = migrations.AddField(
+ "Pony", "height", models.FloatField(null=True, db_default=4)
+ )
+ new_state = project_state.clone()
+ operation.state_forwards(app_label, new_state)
+ self.assertEqual(len(new_state.models[app_label, "pony"].fields), 6)
+ field = new_state.models[app_label, "pony"].fields["height"]
+ self.assertEqual(field.default, models.NOT_PROVIDED)
+ self.assertEqual(field.db_default, Value(4))
+ project_state.apps.get_model(app_label, "pony").objects.create(weight=4)
+ self.assertColumnNotExists(table_name, "height")
+ # Add field.
+ with connection.schema_editor() as editor:
+ operation.database_forwards(app_label, editor, project_state, new_state)
+ self.assertColumnExists(table_name, "height")
+ new_model = new_state.apps.get_model(app_label, "pony")
+ old_pony = new_model.objects.get()
+ self.assertEqual(old_pony.height, 4)
+ new_pony = new_model.objects.create(weight=5)
+ if not connection.features.can_return_columns_from_insert:
+ new_pony.refresh_from_db()
+ self.assertEqual(new_pony.height, 4)
+ # Reversal.
+ with connection.schema_editor() as editor:
+ operation.database_backwards(app_label, editor, new_state, project_state)
+ self.assertColumnNotExists(table_name, "height")
+ # Deconstruction.
+ definition = operation.deconstruct()
+ self.assertEqual(definition[0], "AddField")
+ self.assertEqual(definition[1], [])
+ self.assertEqual(
+ definition[2],
+ {
+ "field": field,
+ "model_name": "Pony",
+ "name": "height",
+ },
+ )
+
+ def test_add_field_database_default_special_char_escaping(self):
+ app_label = "test_adflddsce"
+ table_name = f"{app_label}_pony"
+ project_state = self.set_up_test_model(app_label)
+ old_pony_pk = (
+ project_state.apps.get_model(app_label, "pony").objects.create(weight=4).pk
+ )
+ tests = ["%", "'", '"']
+ for db_default in tests:
+ with self.subTest(db_default=db_default):
+ operation = migrations.AddField(
+ "Pony",
+ "special_char",
+ models.CharField(max_length=1, db_default=db_default),
+ )
+ new_state = project_state.clone()
+ operation.state_forwards(app_label, new_state)
+ self.assertEqual(len(new_state.models[app_label, "pony"].fields), 6)
+ field = new_state.models[app_label, "pony"].fields["special_char"]
+ self.assertEqual(field.default, models.NOT_PROVIDED)
+ self.assertEqual(field.db_default, Value(db_default))
+ self.assertColumnNotExists(table_name, "special_char")
+ with connection.schema_editor() as editor:
+ operation.database_forwards(
+ app_label, editor, project_state, new_state
+ )
+ self.assertColumnExists(table_name, "special_char")
+ new_model = new_state.apps.get_model(app_label, "pony")
+ try:
+ new_pony = new_model.objects.create(weight=5)
+ if not connection.features.can_return_columns_from_insert:
+ new_pony.refresh_from_db()
+ self.assertEqual(new_pony.special_char, db_default)
+
+ old_pony = new_model.objects.get(pk=old_pony_pk)
+ if connection.vendor != "oracle" or db_default != "'":
+ # The single quotation mark ' is properly quoted and is
+ # set for new rows on Oracle, however it is not set on
+ # existing rows. Skip the assertion as it's probably a
+ # bug in Oracle.
+ self.assertEqual(old_pony.special_char, db_default)
+ finally:
+ with connection.schema_editor() as editor:
+ operation.database_backwards(
+ app_label, editor, new_state, project_state
+ )
+
+ @skipUnlessDBFeature("supports_expression_defaults")
+ def test_add_field_database_default_function(self):
+ app_label = "test_adflddf"
+ table_name = f"{app_label}_pony"
+ project_state = self.set_up_test_model(app_label)
+ operation = migrations.AddField(
+ "Pony", "height", models.FloatField(db_default=Pi())
+ )
+ new_state = project_state.clone()
+ operation.state_forwards(app_label, new_state)
+ self.assertEqual(len(new_state.models[app_label, "pony"].fields), 6)
+ field = new_state.models[app_label, "pony"].fields["height"]
+ self.assertEqual(field.default, models.NOT_PROVIDED)
+ self.assertEqual(field.db_default, Pi())
+ project_state.apps.get_model(app_label, "pony").objects.create(weight=4)
+ self.assertColumnNotExists(table_name, "height")
+ # Add field.
+ with connection.schema_editor() as editor:
+ operation.database_forwards(app_label, editor, project_state, new_state)
+ self.assertColumnExists(table_name, "height")
+ new_model = new_state.apps.get_model(app_label, "pony")
+ old_pony = new_model.objects.get()
+ self.assertAlmostEqual(old_pony.height, math.pi)
+ new_pony = new_model.objects.create(weight=5)
+ if not connection.features.can_return_columns_from_insert:
+ new_pony.refresh_from_db()
+ self.assertAlmostEqual(old_pony.height, math.pi)
+
+ def test_add_field_both_defaults(self):
+ """The AddField operation with both default and db_default."""
+ app_label = "test_adflbddd"
+ table_name = f"{app_label}_pony"
+ project_state = self.set_up_test_model(app_label)
+ operation = migrations.AddField(
+ "Pony", "height", models.FloatField(default=3, db_default=4)
+ )
+ new_state = project_state.clone()
+ operation.state_forwards(app_label, new_state)
+ self.assertEqual(len(new_state.models[app_label, "pony"].fields), 6)
+ field = new_state.models[app_label, "pony"].fields["height"]
+ self.assertEqual(field.default, 3)
+ self.assertEqual(field.db_default, Value(4))
+ project_state.apps.get_model(app_label, "pony").objects.create(weight=4)
+ self.assertColumnNotExists(table_name, "height")
+ # Add field.
+ with connection.schema_editor() as editor:
+ operation.database_forwards(app_label, editor, project_state, new_state)
+ self.assertColumnExists(table_name, "height")
+ new_model = new_state.apps.get_model(app_label, "pony")
+ old_pony = new_model.objects.get()
+ self.assertEqual(old_pony.height, 4)
+ new_pony = new_model.objects.create(weight=5)
+ if not connection.features.can_return_columns_from_insert:
+ new_pony.refresh_from_db()
+ self.assertEqual(new_pony.height, 3)
+ # Reversal.
+ with connection.schema_editor() as editor:
+ operation.database_backwards(app_label, editor, new_state, project_state)
+ self.assertColumnNotExists(table_name, "height")
+ # Deconstruction.
+ definition = operation.deconstruct()
+ self.assertEqual(definition[0], "AddField")
+ self.assertEqual(definition[1], [])
+ self.assertEqual(
+ definition[2],
+ {
+ "field": field,
+ "model_name": "Pony",
+ "name": "height",
+ },
+ )
+
+ def test_add_field_m2m(self):
+ """
+ Tests the AddField operation with a ManyToManyField.
+ """
+ project_state = self.set_up_test_model("test_adflmm", second_model=True)
+ # Test the state alteration
+ operation = migrations.AddField(
+ "Pony", "stables", models.ManyToManyField("Stable", related_name="ponies")
+ )
+ new_state = project_state.clone()
+ operation.state_forwards("test_adflmm", new_state)
+ self.assertEqual(len(new_state.models["test_adflmm", "pony"].fields), 6)
+ # Test the database alteration
+ self.assertTableNotExists("test_adflmm_pony_stables")
+ with connection.schema_editor() as editor:
+ operation.database_forwards("test_adflmm", editor, project_state, new_state)
+ self.assertTableExists("test_adflmm_pony_stables")
+ self.assertColumnNotExists("test_adflmm_pony", "stables")
+ # Make sure the M2M field actually works
+ with atomic():
+ Pony = new_state.apps.get_model("test_adflmm", "Pony")
+ p = Pony.objects.create(pink=False, weight=4.55)
+ p.stables.create()
+ self.assertEqual(p.stables.count(), 1)
+ p.stables.all().delete()
+ # And test reversal
+ with connection.schema_editor() as editor:
+ operation.database_backwards(
+ "test_adflmm", editor, new_state, project_state
+ )
+ self.assertTableNotExists("test_adflmm_pony_stables")
+
+ def test_alter_field_m2m(self):
+ project_state = self.set_up_test_model("test_alflmm", second_model=True)
+
+ project_state = self.apply_operations(
+ "test_alflmm",
+ project_state,
+ operations=[
+ migrations.AddField(
+ "Pony",
+ "stables",
+ models.ManyToManyField("Stable", related_name="ponies"),
+ )
+ ],
+ )
+ Pony = project_state.apps.get_model("test_alflmm", "Pony")
+ self.assertFalse(Pony._meta.get_field("stables").blank)
+
+ project_state = self.apply_operations(
+ "test_alflmm",
+ project_state,
+ operations=[
+ migrations.AlterField(
+ "Pony",
+ "stables",
+ models.ManyToManyField(
+ to="Stable", related_name="ponies", blank=True
+ ),
+ )
+ ],
+ )
+ Pony = project_state.apps.get_model("test_alflmm", "Pony")
+ self.assertTrue(Pony._meta.get_field("stables").blank)
+
+ def test_repoint_field_m2m(self):
+ project_state = self.set_up_test_model(
+ "test_alflmm", second_model=True, third_model=True
+ )
+
+ project_state = self.apply_operations(
+ "test_alflmm",
+ project_state,
+ operations=[
+ migrations.AddField(
+ "Pony",
+ "places",
+ models.ManyToManyField("Stable", related_name="ponies"),
+ )
+ ],
+ )
+ Pony = project_state.apps.get_model("test_alflmm", "Pony")
+
+ project_state = self.apply_operations(
+ "test_alflmm",
+ project_state,
+ operations=[
+ migrations.AlterField(
+ "Pony",
+ "places",
+ models.ManyToManyField(to="Van", related_name="ponies"),
+ )
+ ],
+ )
+
+ # Ensure the new field actually works
+ Pony = project_state.apps.get_model("test_alflmm", "Pony")
+ p = Pony.objects.create(pink=False, weight=4.55)
+ p.places.create()
+ self.assertEqual(p.places.count(), 1)
+ p.places.all().delete()
+
+ def test_remove_field_m2m(self):
+ project_state = self.set_up_test_model("test_rmflmm", second_model=True)
+
+ project_state = self.apply_operations(
+ "test_rmflmm",
+ project_state,
+ operations=[
+ migrations.AddField(
+ "Pony",
+ "stables",
+ models.ManyToManyField("Stable", related_name="ponies"),
+ )
+ ],
+ )
+ self.assertTableExists("test_rmflmm_pony_stables")
+
+ with_field_state = project_state.clone()
+ operations = [migrations.RemoveField("Pony", "stables")]
+ project_state = self.apply_operations(
+ "test_rmflmm", project_state, operations=operations
+ )
+ self.assertTableNotExists("test_rmflmm_pony_stables")
+
+ # And test reversal
+ self.unapply_operations("test_rmflmm", with_field_state, operations=operations)
+ self.assertTableExists("test_rmflmm_pony_stables")
+
+ def test_remove_field_m2m_with_through(self):
+ project_state = self.set_up_test_model("test_rmflmmwt", second_model=True)
+
+ self.assertTableNotExists("test_rmflmmwt_ponystables")
+ project_state = self.apply_operations(
+ "test_rmflmmwt",
+ project_state,
+ operations=[
+ migrations.CreateModel(
+ "PonyStables",
+ fields=[
+ (
+ "pony",
+ models.ForeignKey("test_rmflmmwt.Pony", models.CASCADE),
+ ),
+ (
+ "stable",
+ models.ForeignKey("test_rmflmmwt.Stable", models.CASCADE),
+ ),
+ ],
+ ),
+ migrations.AddField(
+ "Pony",
+ "stables",
+ models.ManyToManyField(
+ "Stable",
+ related_name="ponies",
+ through="test_rmflmmwt.PonyStables",
+ ),
+ ),
+ ],
+ )
+ self.assertTableExists("test_rmflmmwt_ponystables")
+
+ operations = [
+ migrations.RemoveField("Pony", "stables"),
+ migrations.DeleteModel("PonyStables"),
+ ]
+ self.apply_operations("test_rmflmmwt", project_state, operations=operations)
+
+ def test_remove_field(self):
+ """
+ Tests the RemoveField operation.
+ """
+ project_state = self.set_up_test_model("test_rmfl")
+ # Test the state alteration
+ operation = migrations.RemoveField("Pony", "pink")
+ self.assertEqual(operation.describe(), "Remove field pink from Pony")
+ self.assertEqual(operation.migration_name_fragment, "remove_pony_pink")
+ new_state = project_state.clone()
+ operation.state_forwards("test_rmfl", new_state)
+ self.assertEqual(len(new_state.models["test_rmfl", "pony"].fields), 4)
+ # Test the database alteration
+ self.assertColumnExists("test_rmfl_pony", "pink")
+ with connection.schema_editor() as editor:
+ operation.database_forwards("test_rmfl", editor, project_state, new_state)
+ self.assertColumnNotExists("test_rmfl_pony", "pink")
+ # And test reversal
+ with connection.schema_editor() as editor:
+ operation.database_backwards("test_rmfl", editor, new_state, project_state)
+ self.assertColumnExists("test_rmfl_pony", "pink")
+ # And deconstruction
+ definition = operation.deconstruct()
+ self.assertEqual(definition[0], "RemoveField")
+ self.assertEqual(definition[1], [])
+ self.assertEqual(definition[2], {"model_name": "Pony", "name": "pink"})
+
+ def test_remove_fk(self):
+ """
+ Tests the RemoveField operation on a foreign key.
+ """
+ project_state = self.set_up_test_model("test_rfk", related_model=True)
+ self.assertColumnExists("test_rfk_rider", "pony_id")
+ operation = migrations.RemoveField("Rider", "pony")
+
+ new_state = project_state.clone()
+ operation.state_forwards("test_rfk", new_state)
+ with connection.schema_editor() as editor:
+ operation.database_forwards("test_rfk", editor, project_state, new_state)
+ self.assertColumnNotExists("test_rfk_rider", "pony_id")
+ with connection.schema_editor() as editor:
+ operation.database_backwards("test_rfk", editor, new_state, project_state)
+ self.assertColumnExists("test_rfk_rider", "pony_id")
+
+ def test_alter_model_table(self):
+ """
+ Tests the AlterModelTable operation.
+ """
+ project_state = self.set_up_test_model("test_almota")
+ # Test the state alteration
+ operation = migrations.AlterModelTable("Pony", "test_almota_pony_2")
+ self.assertEqual(
+ operation.describe(), "Rename table for Pony to test_almota_pony_2"
+ )
+ self.assertEqual(operation.migration_name_fragment, "alter_pony_table")
+ new_state = project_state.clone()
+ operation.state_forwards("test_almota", new_state)
+ self.assertEqual(
+ new_state.models["test_almota", "pony"].options["db_table"],
+ "test_almota_pony_2",
+ )
+ # Test the database alteration
+ self.assertTableExists("test_almota_pony")
+ self.assertTableNotExists("test_almota_pony_2")
+ with connection.schema_editor() as editor:
+ operation.database_forwards("test_almota", editor, project_state, new_state)
+ self.assertTableNotExists("test_almota_pony")
+ self.assertTableExists("test_almota_pony_2")
+ # And test reversal
+ with connection.schema_editor() as editor:
+ operation.database_backwards(
+ "test_almota", editor, new_state, project_state
+ )
+ self.assertTableExists("test_almota_pony")
+ self.assertTableNotExists("test_almota_pony_2")
+ # And deconstruction
+ definition = operation.deconstruct()
+ self.assertEqual(definition[0], "AlterModelTable")
+ self.assertEqual(definition[1], [])
+ self.assertEqual(definition[2], {"name": "Pony", "table": "test_almota_pony_2"})
+
+ def test_alter_model_table_none(self):
+ """
+ Tests the AlterModelTable operation if the table name is set to None.
+ """
+ operation = migrations.AlterModelTable("Pony", None)
+ self.assertEqual(operation.describe(), "Rename table for Pony to (default)")
+
+ def test_alter_model_table_noop(self):
+ """
+ Tests the AlterModelTable operation if the table name is not changed.
+ """
+ project_state = self.set_up_test_model("test_almota")
+ # Test the state alteration
+ operation = migrations.AlterModelTable("Pony", "test_almota_pony")
+ new_state = project_state.clone()
+ operation.state_forwards("test_almota", new_state)
+ self.assertEqual(
+ new_state.models["test_almota", "pony"].options["db_table"],
+ "test_almota_pony",
+ )
+ # Test the database alteration
+ self.assertTableExists("test_almota_pony")
+ with connection.schema_editor() as editor:
+ operation.database_forwards("test_almota", editor, project_state, new_state)
+ self.assertTableExists("test_almota_pony")
+ # And test reversal
+ with connection.schema_editor() as editor:
+ operation.database_backwards(
+ "test_almota", editor, new_state, project_state
+ )
+ self.assertTableExists("test_almota_pony")
+
+ def test_alter_model_table_m2m(self):
+ """
+ AlterModelTable should rename auto-generated M2M tables.
+ """
+ app_label = "test_talflmltlm2m"
+ pony_db_table = "pony_foo"
+ project_state = self.set_up_test_model(
+ app_label, second_model=True, db_table=pony_db_table
+ )
+ # Add the M2M field
+ first_state = project_state.clone()
+ operation = migrations.AddField(
+ "Pony", "stables", models.ManyToManyField("Stable")
+ )
+ operation.state_forwards(app_label, first_state)
+ with connection.schema_editor() as editor:
+ operation.database_forwards(app_label, editor, project_state, first_state)
+ original_m2m_table = "%s_%s" % (pony_db_table, "stables")
+ new_m2m_table = "%s_%s" % (app_label, "pony_stables")
+ self.assertTableExists(original_m2m_table)
+ self.assertTableNotExists(new_m2m_table)
+ # Rename the Pony db_table which should also rename the m2m table.
+ second_state = first_state.clone()
+ operation = migrations.AlterModelTable(name="pony", table=None)
+ operation.state_forwards(app_label, second_state)
+ atomic_rename = connection.features.supports_atomic_references_rename
+ with connection.schema_editor(atomic=atomic_rename) as editor:
+ operation.database_forwards(app_label, editor, first_state, second_state)
+ self.assertTableExists(new_m2m_table)
+ self.assertTableNotExists(original_m2m_table)
+ # And test reversal
+ with connection.schema_editor(atomic=atomic_rename) as editor:
+ operation.database_backwards(app_label, editor, second_state, first_state)
+ self.assertTableExists(original_m2m_table)
+ self.assertTableNotExists(new_m2m_table)
+
+ def test_alter_model_table_m2m_field(self):
+ app_label = "test_talm2mfl"
+ project_state = self.set_up_test_model(app_label, second_model=True)
+ # Add the M2M field.
+ project_state = self.apply_operations(
+ app_label,
+ project_state,
+ operations=[
+ migrations.AddField(
+ "Pony",
+ "stables",
+ models.ManyToManyField("Stable"),
+ )
+ ],
+ )
+ m2m_table = f"{app_label}_pony_stables"
+ self.assertColumnExists(m2m_table, "pony_id")
+ self.assertColumnExists(m2m_table, "stable_id")
+ # Point the M2M field to self.
+ with_field_state = project_state.clone()
+ operations = [
+ migrations.AlterField(
+ model_name="Pony",
+ name="stables",
+ field=models.ManyToManyField("self"),
+ )
+ ]
+ project_state = self.apply_operations(
+ app_label, project_state, operations=operations
+ )
+ self.assertColumnExists(m2m_table, "from_pony_id")
+ self.assertColumnExists(m2m_table, "to_pony_id")
+ # Reversal.
+ self.unapply_operations(app_label, with_field_state, operations=operations)
+ self.assertColumnExists(m2m_table, "pony_id")
+ self.assertColumnExists(m2m_table, "stable_id")
+
+ def test_alter_field(self):
+ """
+ Tests the AlterField operation.
+ """
+ project_state = self.set_up_test_model("test_alfl")
+ # Test the state alteration
+ operation = migrations.AlterField(
+ "Pony", "pink", models.IntegerField(null=True)
+ )
+ self.assertEqual(operation.describe(), "Alter field pink on Pony")
+ self.assertEqual(operation.migration_name_fragment, "alter_pony_pink")
+ new_state = project_state.clone()
+ operation.state_forwards("test_alfl", new_state)
+ self.assertIs(
+ project_state.models["test_alfl", "pony"].fields["pink"].null, False
+ )
+ self.assertIs(new_state.models["test_alfl", "pony"].fields["pink"].null, True)
+ # Test the database alteration
+ self.assertColumnNotNull("test_alfl_pony", "pink")
+ with connection.schema_editor() as editor:
+ operation.database_forwards("test_alfl", editor, project_state, new_state)
+ self.assertColumnNull("test_alfl_pony", "pink")
+ # And test reversal
+ with connection.schema_editor() as editor:
+ operation.database_backwards("test_alfl", editor, new_state, project_state)
+ self.assertColumnNotNull("test_alfl_pony", "pink")
+ # And deconstruction
+ definition = operation.deconstruct()
+ self.assertEqual(definition[0], "AlterField")
+ self.assertEqual(definition[1], [])
+ self.assertEqual(sorted(definition[2]), ["field", "model_name", "name"])
+
+ def test_alter_field_add_database_default(self):
+ app_label = "test_alfladd"
+ project_state = self.set_up_test_model(app_label)
+ operation = migrations.AlterField(
+ "Pony", "weight", models.FloatField(db_default=4.5)
+ )
+ new_state = project_state.clone()
+ operation.state_forwards(app_label, new_state)
+ old_weight = project_state.models[app_label, "pony"].fields["weight"]
+ self.assertIs(old_weight.db_default, models.NOT_PROVIDED)
+ new_weight = new_state.models[app_label, "pony"].fields["weight"]
+ self.assertEqual(new_weight.db_default, Value(4.5))
+ with self.assertRaises(IntegrityError), transaction.atomic():
+ project_state.apps.get_model(app_label, "pony").objects.create()
+ # Alter field.
+ with connection.schema_editor() as editor:
+ operation.database_forwards(app_label, editor, project_state, new_state)
+ pony = new_state.apps.get_model(app_label, "pony").objects.create()
+ if not connection.features.can_return_columns_from_insert:
+ pony.refresh_from_db()
+ self.assertEqual(pony.weight, 4.5)
+ # Reversal.
+ with connection.schema_editor() as editor:
+ operation.database_backwards(app_label, editor, new_state, project_state)
+ with self.assertRaises(IntegrityError), transaction.atomic():
+ project_state.apps.get_model(app_label, "pony").objects.create()
+ # Deconstruction.
+ definition = operation.deconstruct()
+ self.assertEqual(definition[0], "AlterField")
+ self.assertEqual(definition[1], [])
+ self.assertEqual(
+ definition[2],
+ {
+ "field": new_weight,
+ "model_name": "Pony",
+ "name": "weight",
+ },
+ )
+
+ def test_alter_field_change_default_to_database_default(self):
+ """The AlterField operation changing default to db_default."""
+ app_label = "test_alflcdtdd"
+ project_state = self.set_up_test_model(app_label)
+ operation = migrations.AlterField(
+ "Pony", "pink", models.IntegerField(db_default=4)
+ )
+ new_state = project_state.clone()
+ operation.state_forwards(app_label, new_state)
+ old_pink = project_state.models[app_label, "pony"].fields["pink"]
+ self.assertEqual(old_pink.default, 3)
+ self.assertIs(old_pink.db_default, models.NOT_PROVIDED)
+ new_pink = new_state.models[app_label, "pony"].fields["pink"]
+ self.assertIs(new_pink.default, models.NOT_PROVIDED)
+ self.assertEqual(new_pink.db_default, Value(4))
+ pony = project_state.apps.get_model(app_label, "pony").objects.create(weight=1)
+ self.assertEqual(pony.pink, 3)
+ # Alter field.
+ with connection.schema_editor() as editor:
+ operation.database_forwards(app_label, editor, project_state, new_state)
+ pony = new_state.apps.get_model(app_label, "pony").objects.create(weight=1)
+ if not connection.features.can_return_columns_from_insert:
+ pony.refresh_from_db()
+ self.assertEqual(pony.pink, 4)
+ # Reversal.
+ with connection.schema_editor() as editor:
+ operation.database_backwards(app_label, editor, new_state, project_state)
+ pony = project_state.apps.get_model(app_label, "pony").objects.create(weight=1)
+ self.assertEqual(pony.pink, 3)
+
+ def test_alter_field_change_nullable_to_database_default_not_null(self):
+ """
+ The AlterField operation changing a null field to db_default.
+ """
+ app_label = "test_alflcntddnn"
+ project_state = self.set_up_test_model(app_label)
+ operation = migrations.AlterField(
+ "Pony", "green", models.IntegerField(db_default=4)
+ )
+ new_state = project_state.clone()
+ operation.state_forwards(app_label, new_state)
+ old_green = project_state.models[app_label, "pony"].fields["green"]
+ self.assertIs(old_green.db_default, models.NOT_PROVIDED)
+ new_green = new_state.models[app_label, "pony"].fields["green"]
+ self.assertEqual(new_green.db_default, Value(4))
+ old_pony = project_state.apps.get_model(app_label, "pony").objects.create(
+ weight=1
+ )
+ self.assertIsNone(old_pony.green)
+ # Alter field.
+ with connection.schema_editor() as editor:
+ operation.database_forwards(app_label, editor, project_state, new_state)
+ old_pony.refresh_from_db()
+ self.assertEqual(old_pony.green, 4)
+ pony = new_state.apps.get_model(app_label, "pony").objects.create(weight=1)
+ if not connection.features.can_return_columns_from_insert:
+ pony.refresh_from_db()
+ self.assertEqual(pony.green, 4)
+ # Reversal.
+ with connection.schema_editor() as editor:
+ operation.database_backwards(app_label, editor, new_state, project_state)
+ pony = project_state.apps.get_model(app_label, "pony").objects.create(weight=1)
+ self.assertIsNone(pony.green)
+
+ @skipIfDBFeature("interprets_empty_strings_as_nulls")
+ def test_alter_field_change_blank_nullable_database_default_to_not_null(self):
+ app_label = "test_alflcbnddnn"
+ table_name = f"{app_label}_pony"
+ project_state = self.set_up_test_model(app_label)
+ default = "Yellow"
+ operation = migrations.AlterField(
+ "Pony",
+ "yellow",
+ models.CharField(blank=True, db_default=default, max_length=20),
+ )
+ new_state = project_state.clone()
+ operation.state_forwards(app_label, new_state)
+ self.assertColumnNull(table_name, "yellow")
+ pony = project_state.apps.get_model(app_label, "pony").objects.create(
+ weight=1, yellow=None
+ )
+ self.assertIsNone(pony.yellow)
+ # Alter field.
+ with connection.schema_editor() as editor:
+ operation.database_forwards(app_label, editor, project_state, new_state)
+ self.assertColumnNotNull(table_name, "yellow")
+ pony.refresh_from_db()
+ self.assertEqual(pony.yellow, default)
+ pony = new_state.apps.get_model(app_label, "pony").objects.create(weight=1)
+ if not connection.features.can_return_columns_from_insert:
+ pony.refresh_from_db()
+ self.assertEqual(pony.yellow, default)
+ # Reversal.
+ with connection.schema_editor() as editor:
+ operation.database_backwards(app_label, editor, new_state, project_state)
+ self.assertColumnNull(table_name, "yellow")
+ pony = project_state.apps.get_model(app_label, "pony").objects.create(
+ weight=1, yellow=None
+ )
+ self.assertIsNone(pony.yellow)
+
+ def test_alter_field_add_db_column_noop(self):
+ """
+ AlterField operation is a noop when adding only a db_column and the
+ column name is not changed.
+ """
+ app_label = "test_afadbn"
+ project_state = self.set_up_test_model(app_label, related_model=True)
+ pony_table = "%s_pony" % app_label
+ new_state = project_state.clone()
+ operation = migrations.AlterField(
+ "Pony", "weight", models.FloatField(db_column="weight")
+ )
+ operation.state_forwards(app_label, new_state)
+ self.assertIsNone(
+ project_state.models[app_label, "pony"].fields["weight"].db_column,
+ )
+ self.assertEqual(
+ new_state.models[app_label, "pony"].fields["weight"].db_column,
+ "weight",
+ )
+ self.assertColumnExists(pony_table, "weight")
+ with connection.schema_editor() as editor:
+ with self.assertNumQueries(0):
+ operation.database_forwards(app_label, editor, project_state, new_state)
+ self.assertColumnExists(pony_table, "weight")
+ with connection.schema_editor() as editor:
+ with self.assertNumQueries(0):
+ operation.database_backwards(
+ app_label, editor, new_state, project_state
+ )
+ self.assertColumnExists(pony_table, "weight")
+
+ rider_table = "%s_rider" % app_label
+ new_state = project_state.clone()
+ operation = migrations.AlterField(
+ "Rider",
+ "pony",
+ models.ForeignKey("Pony", models.CASCADE, db_column="pony_id"),
+ )
+ operation.state_forwards(app_label, new_state)
+ self.assertIsNone(
+ project_state.models[app_label, "rider"].fields["pony"].db_column,
+ )
+ self.assertIs(
+ new_state.models[app_label, "rider"].fields["pony"].db_column,
+ "pony_id",
+ )
+ self.assertColumnExists(rider_table, "pony_id")
+ with connection.schema_editor() as editor:
+ with self.assertNumQueries(0):
+ operation.database_forwards(app_label, editor, project_state, new_state)
+ self.assertColumnExists(rider_table, "pony_id")
+ with connection.schema_editor() as editor:
+ with self.assertNumQueries(0):
+ operation.database_forwards(app_label, editor, new_state, project_state)
+ self.assertColumnExists(rider_table, "pony_id")
+
+ @skipUnlessDBFeature("supports_comments")
+ def test_alter_model_table_comment(self):
+ app_label = "test_almotaco"
+ project_state = self.set_up_test_model(app_label)
+ pony_table = f"{app_label}_pony"
+ # Add table comment.
+ operation = migrations.AlterModelTableComment("Pony", "Custom pony comment")
+ self.assertEqual(operation.describe(), "Alter Pony table comment")
+ self.assertEqual(operation.migration_name_fragment, "alter_pony_table_comment")
+ new_state = project_state.clone()
+ operation.state_forwards(app_label, new_state)
+ self.assertEqual(
+ new_state.models[app_label, "pony"].options["db_table_comment"],
+ "Custom pony comment",
+ )
+ self.assertTableCommentNotExists(pony_table)
+ with connection.schema_editor() as editor:
+ operation.database_forwards(app_label, editor, project_state, new_state)
+ self.assertTableComment(pony_table, "Custom pony comment")
+ # Reversal.
+ with connection.schema_editor() as editor:
+ operation.database_backwards(app_label, editor, new_state, project_state)
+ self.assertTableCommentNotExists(pony_table)
+ # Deconstruction.
+ definition = operation.deconstruct()
+ self.assertEqual(definition[0], "AlterModelTableComment")
+ self.assertEqual(definition[1], [])
+ self.assertEqual(
+ definition[2], {"name": "Pony", "table_comment": "Custom pony comment"}
+ )
+
+ def test_alter_field_pk(self):
+ """
+ The AlterField operation on primary keys (things like PostgreSQL's
+ SERIAL weirdness).
+ """
+ project_state = self.set_up_test_model("test_alflpk")
+ # Test the state alteration
+ operation = migrations.AlterField(
+ "Pony", "id", models.IntegerField(primary_key=True)
+ )
+ new_state = project_state.clone()
+ operation.state_forwards("test_alflpk", new_state)
+ self.assertIsInstance(
+ project_state.models["test_alflpk", "pony"].fields["id"],
+ models.AutoField,
+ )
+ self.assertIsInstance(
+ new_state.models["test_alflpk", "pony"].fields["id"],
+ models.IntegerField,
+ )
+ # Test the database alteration
+ with connection.schema_editor() as editor:
+ operation.database_forwards("test_alflpk", editor, project_state, new_state)
+ # And test reversal
+ with connection.schema_editor() as editor:
+ operation.database_backwards(
+ "test_alflpk", editor, new_state, project_state
+ )
+
+ @skipUnlessDBFeature("supports_foreign_keys")
+ def test_alter_field_pk_fk(self):
+ """
+ Tests the AlterField operation on primary keys changes any FKs pointing to it.
+ """
+ project_state = self.set_up_test_model("test_alflpkfk", related_model=True)
+ project_state = self.apply_operations(
+ "test_alflpkfk",
+ project_state,
+ [
+ migrations.CreateModel(
+ "Stable",
+ fields=[
+ ("ponies", models.ManyToManyField("Pony")),
+ ],
+ ),
+ migrations.AddField(
+ "Pony",
+ "stables",
+ models.ManyToManyField("Stable"),
+ ),
+ ],
+ )
+ # Test the state alteration
+ operation = migrations.AlterField(
+ "Pony", "id", models.FloatField(primary_key=True)
+ )
+ new_state = project_state.clone()
+ operation.state_forwards("test_alflpkfk", new_state)
+ self.assertIsInstance(
+ project_state.models["test_alflpkfk", "pony"].fields["id"],
+ models.AutoField,
+ )
+ self.assertIsInstance(
+ new_state.models["test_alflpkfk", "pony"].fields["id"],
+ models.FloatField,
+ )
+
+ def assertIdTypeEqualsFkType():
+ with connection.cursor() as cursor:
+ id_type, id_null = [
+ (c.type_code, c.null_ok)
+ for c in connection.introspection.get_table_description(
+ cursor, "test_alflpkfk_pony"
+ )
+ if c.name == "id"
+ ][0]
+ fk_type, fk_null = [
+ (c.type_code, c.null_ok)
+ for c in connection.introspection.get_table_description(
+ cursor, "test_alflpkfk_rider"
+ )
+ if c.name == "pony_id"
+ ][0]
+ m2m_fk_type, m2m_fk_null = [
+ (c.type_code, c.null_ok)
+ for c in connection.introspection.get_table_description(
+ cursor,
+ "test_alflpkfk_pony_stables",
+ )
+ if c.name == "pony_id"
+ ][0]
+ remote_m2m_fk_type, remote_m2m_fk_null = [
+ (c.type_code, c.null_ok)
+ for c in connection.introspection.get_table_description(
+ cursor,
+ "test_alflpkfk_stable_ponies",
+ )
+ if c.name == "pony_id"
+ ][0]
+ self.assertEqual(id_type, fk_type)
+ self.assertEqual(id_type, m2m_fk_type)
+ self.assertEqual(id_type, remote_m2m_fk_type)
+ self.assertEqual(id_null, fk_null)
+ self.assertEqual(id_null, m2m_fk_null)
+ self.assertEqual(id_null, remote_m2m_fk_null)
+
+ assertIdTypeEqualsFkType()
+ # Test the database alteration
+ with connection.schema_editor() as editor:
+ operation.database_forwards(
+ "test_alflpkfk", editor, project_state, new_state
+ )
+ assertIdTypeEqualsFkType()
+ if connection.features.supports_foreign_keys:
+ self.assertFKExists(
+ "test_alflpkfk_pony_stables",
+ ["pony_id"],
+ ("test_alflpkfk_pony", "id"),
+ )
+ self.assertFKExists(
+ "test_alflpkfk_stable_ponies",
+ ["pony_id"],
+ ("test_alflpkfk_pony", "id"),
+ )
+ # And test reversal
+ with connection.schema_editor() as editor:
+ operation.database_backwards(
+ "test_alflpkfk", editor, new_state, project_state
+ )
+ assertIdTypeEqualsFkType()
+ if connection.features.supports_foreign_keys:
+ self.assertFKExists(
+ "test_alflpkfk_pony_stables",
+ ["pony_id"],
+ ("test_alflpkfk_pony", "id"),
+ )
+ self.assertFKExists(
+ "test_alflpkfk_stable_ponies",
+ ["pony_id"],
+ ("test_alflpkfk_pony", "id"),
+ )
+
+ @skipUnlessDBFeature("supports_collation_on_charfield", "supports_foreign_keys")
+ def test_alter_field_pk_fk_db_collation(self):
+ """
+ AlterField operation of db_collation on primary keys changes any FKs
+ pointing to it.
+ """
+ collation = connection.features.test_collations.get("non_default")
+ if not collation:
+ self.skipTest("Language collations are not supported.")
+
+ app_label = "test_alflpkfkdbc"
+ project_state = self.apply_operations(
+ app_label,
+ ProjectState(),
+ [
+ migrations.CreateModel(
+ "Pony",
+ [
+ ("id", models.CharField(primary_key=True, max_length=10)),
+ ],
+ ),
+ migrations.CreateModel(
+ "Rider",
+ [
+ ("pony", models.ForeignKey("Pony", models.CASCADE)),
+ ],
+ ),
+ migrations.CreateModel(
+ "Stable",
+ [
+ ("ponies", models.ManyToManyField("Pony")),
+ ],
+ ),
+ ],
+ )
+ # State alteration.
+ operation = migrations.AlterField(
+ "Pony",
+ "id",
+ models.CharField(
+ primary_key=True,
+ max_length=10,
+ db_collation=collation,
+ ),
+ )
+ new_state = project_state.clone()
+ operation.state_forwards(app_label, new_state)
+ # Database alteration.
+ with connection.schema_editor() as editor:
+ operation.database_forwards(app_label, editor, project_state, new_state)
+ self.assertColumnCollation(f"{app_label}_pony", "id", collation)
+ self.assertColumnCollation(f"{app_label}_rider", "pony_id", collation)
+ self.assertColumnCollation(f"{app_label}_stable_ponies", "pony_id", collation)
+ # Reversal.
+ with connection.schema_editor() as editor:
+ operation.database_backwards(app_label, editor, new_state, project_state)
+
+ def test_alter_field_pk_mti_fk(self):
+ app_label = "test_alflpkmtifk"
+ project_state = self.set_up_test_model(app_label, mti_model=True)
+ project_state = self.apply_operations(
+ app_label,
+ project_state,
+ [
+ migrations.CreateModel(
+ "ShetlandRider",
+ fields=[
+ (
+ "pony",
+ models.ForeignKey(
+ f"{app_label}.ShetlandPony", models.CASCADE
+ ),
+ ),
+ ],
+ ),
+ ],
+ )
+ operation = migrations.AlterField(
+ "Pony",
+ "id",
+ models.BigAutoField(primary_key=True),
+ )
+ new_state = project_state.clone()
+ operation.state_forwards(app_label, new_state)
+ self.assertIsInstance(
+ new_state.models[app_label, "pony"].fields["id"],
+ models.BigAutoField,
+ )
+
+ def _get_column_id_type(cursor, table, column):
+ return [
+ c.type_code
+ for c in connection.introspection.get_table_description(
+ cursor,
+ f"{app_label}_{table}",
+ )
+ if c.name == column
+ ][0]
+
+ def assertIdTypeEqualsMTIFkType():
+ with connection.cursor() as cursor:
+ parent_id_type = _get_column_id_type(cursor, "pony", "id")
+ child_id_type = _get_column_id_type(
+ cursor, "shetlandpony", "pony_ptr_id"
+ )
+ mti_id_type = _get_column_id_type(cursor, "shetlandrider", "pony_id")
+ self.assertEqual(parent_id_type, child_id_type)
+ self.assertEqual(parent_id_type, mti_id_type)
+
+ assertIdTypeEqualsMTIFkType()
+ # Alter primary key.
+ with connection.schema_editor() as editor:
+ operation.database_forwards(app_label, editor, project_state, new_state)
+ assertIdTypeEqualsMTIFkType()
+ if connection.features.supports_foreign_keys:
+ self.assertFKExists(
+ f"{app_label}_shetlandpony",
+ ["pony_ptr_id"],
+ (f"{app_label}_pony", "id"),
+ )
+ self.assertFKExists(
+ f"{app_label}_shetlandrider",
+ ["pony_id"],
+ (f"{app_label}_shetlandpony", "pony_ptr_id"),
+ )
+ # Reversal.
+ with connection.schema_editor() as editor:
+ operation.database_backwards(app_label, editor, new_state, project_state)
+ assertIdTypeEqualsMTIFkType()
+ if connection.features.supports_foreign_keys:
+ self.assertFKExists(
+ f"{app_label}_shetlandpony",
+ ["pony_ptr_id"],
+ (f"{app_label}_pony", "id"),
+ )
+ self.assertFKExists(
+ f"{app_label}_shetlandrider",
+ ["pony_id"],
+ (f"{app_label}_shetlandpony", "pony_ptr_id"),
+ )
+
+ def test_alter_field_pk_mti_and_fk_to_base(self):
+ app_label = "test_alflpkmtiftb"
+ project_state = self.set_up_test_model(
+ app_label,
+ mti_model=True,
+ related_model=True,
+ )
+ operation = migrations.AlterField(
+ "Pony",
+ "id",
+ models.BigAutoField(primary_key=True),
+ )
+ new_state = project_state.clone()
+ operation.state_forwards(app_label, new_state)
+ self.assertIsInstance(
+ new_state.models[app_label, "pony"].fields["id"],
+ models.BigAutoField,
+ )
+
+ def _get_column_id_type(cursor, table, column):
+ return [
+ c.type_code
+ for c in connection.introspection.get_table_description(
+ cursor,
+ f"{app_label}_{table}",
+ )
+ if c.name == column
+ ][0]
+
+ def assertIdTypeEqualsMTIFkType():
+ with connection.cursor() as cursor:
+ parent_id_type = _get_column_id_type(cursor, "pony", "id")
+ fk_id_type = _get_column_id_type(cursor, "rider", "pony_id")
+ child_id_type = _get_column_id_type(
+ cursor, "shetlandpony", "pony_ptr_id"
+ )
+ self.assertEqual(parent_id_type, child_id_type)
+ self.assertEqual(parent_id_type, fk_id_type)
+
+ assertIdTypeEqualsMTIFkType()
+ # Alter primary key.
+ with connection.schema_editor() as editor:
+ operation.database_forwards(app_label, editor, project_state, new_state)
+ assertIdTypeEqualsMTIFkType()
+ if connection.features.supports_foreign_keys:
+ self.assertFKExists(
+ f"{app_label}_shetlandpony",
+ ["pony_ptr_id"],
+ (f"{app_label}_pony", "id"),
+ )
+ self.assertFKExists(
+ f"{app_label}_rider",
+ ["pony_id"],
+ (f"{app_label}_pony", "id"),
+ )
+ # Reversal.
+ with connection.schema_editor() as editor:
+ operation.database_backwards(app_label, editor, new_state, project_state)
+ assertIdTypeEqualsMTIFkType()
+ if connection.features.supports_foreign_keys:
+ self.assertFKExists(
+ f"{app_label}_shetlandpony",
+ ["pony_ptr_id"],
+ (f"{app_label}_pony", "id"),
+ )
+ self.assertFKExists(
+ f"{app_label}_rider",
+ ["pony_id"],
+ (f"{app_label}_pony", "id"),
+ )
+
+ @skipUnlessDBFeature("supports_foreign_keys")
+ def test_alter_field_reloads_state_on_fk_with_to_field_target_type_change(self):
+ app_label = "test_alflrsfkwtflttc"
+ project_state = self.apply_operations(
+ app_label,
+ ProjectState(),
+ operations=[
+ migrations.CreateModel(
+ "Rider",
+ fields=[
+ ("id", models.AutoField(primary_key=True)),
+ ("code", models.IntegerField(unique=True)),
+ ],
+ ),
+ migrations.CreateModel(
+ "Pony",
+ fields=[
+ ("id", models.AutoField(primary_key=True)),
+ (
+ "rider",
+ models.ForeignKey(
+ "%s.Rider" % app_label, models.CASCADE, to_field="code"
+ ),
+ ),
+ ],
+ ),
+ ],
+ )
+ operation = migrations.AlterField(
+ "Rider",
+ "code",
+ models.CharField(max_length=100, unique=True),
+ )
+ self.apply_operations(app_label, project_state, operations=[operation])
+ id_type, id_null = [
+ (c.type_code, c.null_ok)
+ for c in self.get_table_description("%s_rider" % app_label)
+ if c.name == "code"
+ ][0]
+ fk_type, fk_null = [
+ (c.type_code, c.null_ok)
+ for c in self.get_table_description("%s_pony" % app_label)
+ if c.name == "rider_id"
+ ][0]
+ self.assertEqual(id_type, fk_type)
+ self.assertEqual(id_null, fk_null)
+
+ @skipUnlessDBFeature("supports_foreign_keys")
+ def test_alter_field_reloads_state_fk_with_to_field_related_name_target_type_change(
+ self,
+ ):
+ app_label = "test_alflrsfkwtflrnttc"
+ project_state = self.apply_operations(
+ app_label,
+ ProjectState(),
+ operations=[
+ migrations.CreateModel(
+ "Rider",
+ fields=[
+ ("id", models.AutoField(primary_key=True)),
+ ("code", models.PositiveIntegerField(unique=True)),
+ ],
+ ),
+ migrations.CreateModel(
+ "Pony",
+ fields=[
+ ("id", models.AutoField(primary_key=True)),
+ (
+ "rider",
+ models.ForeignKey(
+ "%s.Rider" % app_label,
+ models.CASCADE,
+ to_field="code",
+ related_name="+",
+ ),
+ ),
+ ],
+ ),
+ ],
+ )
+ operation = migrations.AlterField(
+ "Rider",
+ "code",
+ models.CharField(max_length=100, unique=True),
+ )
+ self.apply_operations(app_label, project_state, operations=[operation])
+
+ def test_alter_field_reloads_state_on_fk_target_changes(self):
+ """
+ If AlterField doesn't reload state appropriately, the second AlterField
+ crashes on MySQL due to not dropping the PonyRider.pony foreign key
+ constraint before modifying the column.
+ """
+ app_label = "alter_alter_field_reloads_state_on_fk_target_changes"
+ project_state = self.apply_operations(
+ app_label,
+ ProjectState(),
+ operations=[
+ migrations.CreateModel(
+ "Rider",
+ fields=[
+ ("id", models.CharField(primary_key=True, max_length=100)),
+ ],
+ ),
+ migrations.CreateModel(
+ "Pony",
+ fields=[
+ ("id", models.CharField(primary_key=True, max_length=100)),
+ (
+ "rider",
+ models.ForeignKey("%s.Rider" % app_label, models.CASCADE),
+ ),
+ ],
+ ),
+ migrations.CreateModel(
+ "PonyRider",
+ fields=[
+ ("id", models.AutoField(primary_key=True)),
+ (
+ "pony",
+ models.ForeignKey("%s.Pony" % app_label, models.CASCADE),
+ ),
+ ],
+ ),
+ ],
+ )
+ project_state = self.apply_operations(
+ app_label,
+ project_state,
+ operations=[
+ migrations.AlterField(
+ "Rider", "id", models.CharField(primary_key=True, max_length=99)
+ ),
+ migrations.AlterField(
+ "Pony", "id", models.CharField(primary_key=True, max_length=99)
+ ),
+ ],
+ )
+
+ def test_alter_field_reloads_state_on_fk_with_to_field_target_changes(self):
+ """
+ If AlterField doesn't reload state appropriately, the second AlterField
+ crashes on MySQL due to not dropping the PonyRider.pony foreign key
+ constraint before modifying the column.
+ """
+ app_label = "alter_alter_field_reloads_state_on_fk_with_to_field_target_changes"
+ project_state = self.apply_operations(
+ app_label,
+ ProjectState(),
+ operations=[
+ migrations.CreateModel(
+ "Rider",
+ fields=[
+ ("id", models.CharField(primary_key=True, max_length=100)),
+ ("slug", models.CharField(unique=True, max_length=100)),
+ ],
+ ),
+ migrations.CreateModel(
+ "Pony",
+ fields=[
+ ("id", models.CharField(primary_key=True, max_length=100)),
+ (
+ "rider",
+ models.ForeignKey(
+ "%s.Rider" % app_label, models.CASCADE, to_field="slug"
+ ),
+ ),
+ ("slug", models.CharField(unique=True, max_length=100)),
+ ],
+ ),
+ migrations.CreateModel(
+ "PonyRider",
+ fields=[
+ ("id", models.AutoField(primary_key=True)),
+ (
+ "pony",
+ models.ForeignKey(
+ "%s.Pony" % app_label, models.CASCADE, to_field="slug"
+ ),
+ ),
+ ],
+ ),
+ ],
+ )
+ project_state = self.apply_operations(
+ app_label,
+ project_state,
+ operations=[
+ migrations.AlterField(
+ "Rider", "slug", models.CharField(unique=True, max_length=99)
+ ),
+ migrations.AlterField(
+ "Pony", "slug", models.CharField(unique=True, max_length=99)
+ ),
+ ],
+ )
+
+ def test_alter_field_pk_fk_char_to_int(self):
+ app_label = "alter_field_pk_fk_char_to_int"
+ project_state = self.apply_operations(
+ app_label,
+ ProjectState(),
+ operations=[
+ migrations.CreateModel(
+ name="Parent",
+ fields=[
+ ("id", models.CharField(max_length=255, primary_key=True)),
+ ],
+ ),
+ migrations.CreateModel(
+ name="Child",
+ fields=[
+ ("id", models.BigAutoField(primary_key=True)),
+ (
+ "parent",
+ models.ForeignKey(
+ f"{app_label}.Parent",
+ on_delete=models.CASCADE,
+ ),
+ ),
+ ],
+ ),
+ ],
+ )
+ self.apply_operations(
+ app_label,
+ project_state,
+ operations=[
+ migrations.AlterField(
+ model_name="parent",
+ name="id",
+ field=models.BigIntegerField(primary_key=True),
+ ),
+ ],
+ )
+
+ def test_rename_field_reloads_state_on_fk_target_changes(self):
+ """
+ If RenameField doesn't reload state appropriately, the AlterField
+ crashes on MySQL due to not dropping the PonyRider.pony foreign key
+ constraint before modifying the column.
+ """
+ app_label = "alter_rename_field_reloads_state_on_fk_target_changes"
+ project_state = self.apply_operations(
+ app_label,
+ ProjectState(),
+ operations=[
+ migrations.CreateModel(
+ "Rider",
+ fields=[
+ ("id", models.CharField(primary_key=True, max_length=100)),
+ ],
+ ),
+ migrations.CreateModel(
+ "Pony",
+ fields=[
+ ("id", models.CharField(primary_key=True, max_length=100)),
+ (
+ "rider",
+ models.ForeignKey("%s.Rider" % app_label, models.CASCADE),
+ ),
+ ],
+ ),
+ migrations.CreateModel(
+ "PonyRider",
+ fields=[
+ ("id", models.AutoField(primary_key=True)),
+ (
+ "pony",
+ models.ForeignKey("%s.Pony" % app_label, models.CASCADE),
+ ),
+ ],
+ ),
+ ],
+ )
+ project_state = self.apply_operations(
+ app_label,
+ project_state,
+ operations=[
+ migrations.RenameField("Rider", "id", "id2"),
+ migrations.AlterField(
+ "Pony", "id", models.CharField(primary_key=True, max_length=99)
+ ),
+ ],
+ atomic=connection.features.supports_atomic_references_rename,
+ )
+
+ def test_rename_field(self):
+ """
+ Tests the RenameField operation.
+ """
+ project_state = self.set_up_test_model("test_rnfl")
+ operation = migrations.RenameField("Pony", "pink", "blue")
+ self.assertEqual(operation.describe(), "Rename field pink on Pony to blue")
+ self.assertEqual(operation.migration_name_fragment, "rename_pink_pony_blue")
+ new_state = project_state.clone()
+ operation.state_forwards("test_rnfl", new_state)
+ self.assertIn("blue", new_state.models["test_rnfl", "pony"].fields)
+ self.assertNotIn("pink", new_state.models["test_rnfl", "pony"].fields)
+ # Rename field.
+ self.assertColumnExists("test_rnfl_pony", "pink")
+ self.assertColumnNotExists("test_rnfl_pony", "blue")
+ with connection.schema_editor() as editor:
+ operation.database_forwards("test_rnfl", editor, project_state, new_state)
+ self.assertColumnExists("test_rnfl_pony", "blue")
+ self.assertColumnNotExists("test_rnfl_pony", "pink")
+ # Reversal.
+ with connection.schema_editor() as editor:
+ operation.database_backwards("test_rnfl", editor, new_state, project_state)
+ self.assertColumnExists("test_rnfl_pony", "pink")
+ self.assertColumnNotExists("test_rnfl_pony", "blue")
+ # Deconstruction.
+ definition = operation.deconstruct()
+ self.assertEqual(definition[0], "RenameField")
+ self.assertEqual(definition[1], [])
+ self.assertEqual(
+ definition[2],
+ {"model_name": "Pony", "old_name": "pink", "new_name": "blue"},
+ )
+
+ def test_rename_field_unique_together(self):
+ project_state = self.set_up_test_model("test_rnflut", unique_together=True)
+ operation = migrations.RenameField("Pony", "pink", "blue")
+ new_state = project_state.clone()
+ operation.state_forwards("test_rnflut", new_state)
+ # unique_together has the renamed column.
+ self.assertIn(
+ "blue",
+ new_state.models["test_rnflut", "pony"].options["unique_together"][0],
+ )
+ self.assertNotIn(
+ "pink",
+ new_state.models["test_rnflut", "pony"].options["unique_together"][0],
+ )
+ # Rename field.
+ self.assertColumnExists("test_rnflut_pony", "pink")
+ self.assertColumnNotExists("test_rnflut_pony", "blue")
+ with connection.schema_editor() as editor:
+ operation.database_forwards("test_rnflut", editor, project_state, new_state)
+ self.assertColumnExists("test_rnflut_pony", "blue")
+ self.assertColumnNotExists("test_rnflut_pony", "pink")
+ # The unique constraint has been ported over.
+ with connection.cursor() as cursor:
+ cursor.execute("INSERT INTO test_rnflut_pony (blue, weight) VALUES (1, 1)")
+ with self.assertRaises(IntegrityError):
+ with atomic():
+ cursor.execute(
+ "INSERT INTO test_rnflut_pony (blue, weight) VALUES (1, 1)"
+ )
+ cursor.execute("DELETE FROM test_rnflut_pony")
+ # Reversal.
+ with connection.schema_editor() as editor:
+ operation.database_backwards(
+ "test_rnflut", editor, new_state, project_state
+ )
+ self.assertColumnExists("test_rnflut_pony", "pink")
+ self.assertColumnNotExists("test_rnflut_pony", "blue")
+
+ @ignore_warnings(category=RemovedInDjango51Warning)
+ def test_rename_field_index_together(self):
+ project_state = self.set_up_test_model("test_rnflit", index_together=True)
+ operation = migrations.RenameField("Pony", "pink", "blue")
+ new_state = project_state.clone()
+ operation.state_forwards("test_rnflit", new_state)
+ self.assertIn("blue", new_state.models["test_rnflit", "pony"].fields)
+ self.assertNotIn("pink", new_state.models["test_rnflit", "pony"].fields)
+ # index_together has the renamed column.
+ self.assertIn(
+ "blue", new_state.models["test_rnflit", "pony"].options["index_together"][0]
+ )
+ self.assertNotIn(
+ "pink", new_state.models["test_rnflit", "pony"].options["index_together"][0]
+ )
+ # Rename field.
+ self.assertColumnExists("test_rnflit_pony", "pink")
+ self.assertColumnNotExists("test_rnflit_pony", "blue")
+ with connection.schema_editor() as editor:
+ operation.database_forwards("test_rnflit", editor, project_state, new_state)
+ self.assertColumnExists("test_rnflit_pony", "blue")
+ self.assertColumnNotExists("test_rnflit_pony", "pink")
+ # The index constraint has been ported over.
+ self.assertIndexExists("test_rnflit_pony", ["weight", "blue"])
+ # Reversal.
+ with connection.schema_editor() as editor:
+ operation.database_backwards(
+ "test_rnflit", editor, new_state, project_state
+ )
+ self.assertIndexExists("test_rnflit_pony", ["weight", "pink"])
+
+ def test_rename_field_with_db_column(self):
+ project_state = self.apply_operations(
+ "test_rfwdbc",
+ ProjectState(),
+ operations=[
+ migrations.CreateModel(
+ "Pony",
+ fields=[
+ ("id", models.AutoField(primary_key=True)),
+ ("field", models.IntegerField(db_column="db_field")),
+ (
+ "fk_field",
+ models.ForeignKey(
+ "Pony",
+ models.CASCADE,
+ db_column="db_fk_field",
+ ),
+ ),
+ ],
+ ),
+ ],
+ )
+ new_state = project_state.clone()
+ operation = migrations.RenameField("Pony", "field", "renamed_field")
+ operation.state_forwards("test_rfwdbc", new_state)
+ self.assertIn("renamed_field", new_state.models["test_rfwdbc", "pony"].fields)
+ self.assertNotIn("field", new_state.models["test_rfwdbc", "pony"].fields)
+ self.assertColumnExists("test_rfwdbc_pony", "db_field")
+ with connection.schema_editor() as editor:
+ with self.assertNumQueries(0):
+ operation.database_forwards(
+ "test_rfwdbc", editor, project_state, new_state
+ )
+ self.assertColumnExists("test_rfwdbc_pony", "db_field")
+ with connection.schema_editor() as editor:
+ with self.assertNumQueries(0):
+ operation.database_backwards(
+ "test_rfwdbc", editor, new_state, project_state
+ )
+ self.assertColumnExists("test_rfwdbc_pony", "db_field")
+
+ new_state = project_state.clone()
+ operation = migrations.RenameField("Pony", "fk_field", "renamed_fk_field")
+ operation.state_forwards("test_rfwdbc", new_state)
+ self.assertIn(
+ "renamed_fk_field", new_state.models["test_rfwdbc", "pony"].fields
+ )
+ self.assertNotIn("fk_field", new_state.models["test_rfwdbc", "pony"].fields)
+ self.assertColumnExists("test_rfwdbc_pony", "db_fk_field")
+ with connection.schema_editor() as editor:
+ with self.assertNumQueries(0):
+ operation.database_forwards(
+ "test_rfwdbc", editor, project_state, new_state
+ )
+ self.assertColumnExists("test_rfwdbc_pony", "db_fk_field")
+ with connection.schema_editor() as editor:
+ with self.assertNumQueries(0):
+ operation.database_backwards(
+ "test_rfwdbc", editor, new_state, project_state
+ )
+ self.assertColumnExists("test_rfwdbc_pony", "db_fk_field")
+
+ def test_rename_field_case(self):
+ project_state = self.apply_operations(
+ "test_rfmx",
+ ProjectState(),
+ operations=[
+ migrations.CreateModel(
+ "Pony",
+ fields=[
+ ("id", models.AutoField(primary_key=True)),
+ ("field", models.IntegerField()),
+ ],
+ ),
+ ],
+ )
+ new_state = project_state.clone()
+ operation = migrations.RenameField("Pony", "field", "FiElD")
+ operation.state_forwards("test_rfmx", new_state)
+ self.assertIn("FiElD", new_state.models["test_rfmx", "pony"].fields)
+ self.assertColumnExists("test_rfmx_pony", "field")
+ with connection.schema_editor() as editor:
+ operation.database_forwards("test_rfmx", editor, project_state, new_state)
+ self.assertColumnExists(
+ "test_rfmx_pony",
+ connection.introspection.identifier_converter("FiElD"),
+ )
+ with connection.schema_editor() as editor:
+ operation.database_backwards("test_rfmx", editor, new_state, project_state)
+ self.assertColumnExists("test_rfmx_pony", "field")
+
+ def test_rename_missing_field(self):
+ state = ProjectState()
+ state.add_model(ModelState("app", "model", []))
+ with self.assertRaisesMessage(
+ FieldDoesNotExist, "app.model has no field named 'field'"
+ ):
+ migrations.RenameField("model", "field", "new_field").state_forwards(
+ "app", state
+ )
+
+ def test_rename_referenced_field_state_forward(self):
+ state = ProjectState()
+ state.add_model(
+ ModelState(
+ "app",
+ "Model",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ("field", models.IntegerField(unique=True)),
+ ],
+ )
+ )
+ state.add_model(
+ ModelState(
+ "app",
+ "OtherModel",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ (
+ "fk",
+ models.ForeignKey("Model", models.CASCADE, to_field="field"),
+ ),
+ (
+ "fo",
+ models.ForeignObject(
+ "Model",
+ models.CASCADE,
+ from_fields=("fk",),
+ to_fields=("field",),
+ ),
+ ),
+ ],
+ )
+ )
+ operation = migrations.RenameField("Model", "field", "renamed")
+ new_state = state.clone()
+ operation.state_forwards("app", new_state)
+ self.assertEqual(
+ new_state.models["app", "othermodel"].fields["fk"].remote_field.field_name,
+ "renamed",
+ )
+ self.assertEqual(
+ new_state.models["app", "othermodel"].fields["fk"].from_fields, ["self"]
+ )
+ self.assertEqual(
+ new_state.models["app", "othermodel"].fields["fk"].to_fields, ("renamed",)
+ )
+ self.assertEqual(
+ new_state.models["app", "othermodel"].fields["fo"].from_fields, ("fk",)
+ )
+ self.assertEqual(
+ new_state.models["app", "othermodel"].fields["fo"].to_fields, ("renamed",)
+ )
+ operation = migrations.RenameField("OtherModel", "fk", "renamed_fk")
+ new_state = state.clone()
+ operation.state_forwards("app", new_state)
+ self.assertEqual(
+ new_state.models["app", "othermodel"]
+ .fields["renamed_fk"]
+ .remote_field.field_name,
+ "renamed",
+ )
+ self.assertEqual(
+ new_state.models["app", "othermodel"].fields["renamed_fk"].from_fields,
+ ("self",),
+ )
+ self.assertEqual(
+ new_state.models["app", "othermodel"].fields["renamed_fk"].to_fields,
+ ("renamed",),
+ )
+ self.assertEqual(
+ new_state.models["app", "othermodel"].fields["fo"].from_fields,
+ ("renamed_fk",),
+ )
+ self.assertEqual(
+ new_state.models["app", "othermodel"].fields["fo"].to_fields, ("renamed",)
+ )
+
+ def test_alter_unique_together(self):
+ """
+ Tests the AlterUniqueTogether operation.
+ """
+ project_state = self.set_up_test_model("test_alunto")
+ # Test the state alteration
+ operation = migrations.AlterUniqueTogether("Pony", [("pink", "weight")])
+ self.assertEqual(
+ operation.describe(), "Alter unique_together for Pony (1 constraint(s))"
+ )
+ self.assertEqual(
+ operation.migration_name_fragment,
+ "alter_pony_unique_together",
+ )
+ new_state = project_state.clone()
+ operation.state_forwards("test_alunto", new_state)
+ self.assertEqual(
+ len(
+ project_state.models["test_alunto", "pony"].options.get(
+ "unique_together", set()
+ )
+ ),
+ 0,
+ )
+ self.assertEqual(
+ len(
+ new_state.models["test_alunto", "pony"].options.get(
+ "unique_together", set()
+ )
+ ),
+ 1,
+ )
+ # Make sure we can insert duplicate rows
+ with connection.cursor() as cursor:
+ cursor.execute("INSERT INTO test_alunto_pony (pink, weight) VALUES (1, 1)")
+ cursor.execute("INSERT INTO test_alunto_pony (pink, weight) VALUES (1, 1)")
+ cursor.execute("DELETE FROM test_alunto_pony")
+ # Test the database alteration
+ with connection.schema_editor() as editor:
+ operation.database_forwards(
+ "test_alunto", editor, project_state, new_state
+ )
+ cursor.execute("INSERT INTO test_alunto_pony (pink, weight) VALUES (1, 1)")
+ with self.assertRaises(IntegrityError):
+ with atomic():
+ cursor.execute(
+ "INSERT INTO test_alunto_pony (pink, weight) VALUES (1, 1)"
+ )
+ cursor.execute("DELETE FROM test_alunto_pony")
+ # And test reversal
+ with connection.schema_editor() as editor:
+ operation.database_backwards(
+ "test_alunto", editor, new_state, project_state
+ )
+ cursor.execute("INSERT INTO test_alunto_pony (pink, weight) VALUES (1, 1)")
+ cursor.execute("INSERT INTO test_alunto_pony (pink, weight) VALUES (1, 1)")
+ cursor.execute("DELETE FROM test_alunto_pony")
+ # Test flat unique_together
+ operation = migrations.AlterUniqueTogether("Pony", ("pink", "weight"))
+ operation.state_forwards("test_alunto", new_state)
+ self.assertEqual(
+ len(
+ new_state.models["test_alunto", "pony"].options.get(
+ "unique_together", set()
+ )
+ ),
+ 1,
+ )
+ # And deconstruction
+ definition = operation.deconstruct()
+ self.assertEqual(definition[0], "AlterUniqueTogether")
+ self.assertEqual(definition[1], [])
+ self.assertEqual(
+ definition[2], {"name": "Pony", "unique_together": {("pink", "weight")}}
+ )
+
+ def test_alter_unique_together_remove(self):
+ operation = migrations.AlterUniqueTogether("Pony", None)
+ self.assertEqual(
+ operation.describe(), "Alter unique_together for Pony (0 constraint(s))"
+ )
+
+ @skipUnlessDBFeature("allows_multiple_constraints_on_same_fields")
+ def test_remove_unique_together_on_pk_field(self):
+ app_label = "test_rutopkf"
+ project_state = self.apply_operations(
+ app_label,
+ ProjectState(),
+ operations=[
+ migrations.CreateModel(
+ "Pony",
+ fields=[("id", models.AutoField(primary_key=True))],
+ options={"unique_together": {("id",)}},
+ ),
+ ],
+ )
+ table_name = f"{app_label}_pony"
+ pk_constraint_name = f"{table_name}_pkey"
+ unique_together_constraint_name = f"{table_name}_id_fb61f881_uniq"
+ self.assertConstraintExists(table_name, pk_constraint_name, value=False)
+ self.assertConstraintExists(
+ table_name, unique_together_constraint_name, value=False
+ )
+
+ new_state = project_state.clone()
+ operation = migrations.AlterUniqueTogether("Pony", set())
+ operation.state_forwards(app_label, new_state)
+ with connection.schema_editor() as editor:
+ operation.database_forwards(app_label, editor, project_state, new_state)
+ self.assertConstraintExists(table_name, pk_constraint_name, value=False)
+ self.assertConstraintNotExists(table_name, unique_together_constraint_name)
+
+ @skipUnlessDBFeature("allows_multiple_constraints_on_same_fields")
+ def test_remove_unique_together_on_unique_field(self):
+ app_label = "test_rutouf"
+ project_state = self.apply_operations(
+ app_label,
+ ProjectState(),
+ operations=[
+ migrations.CreateModel(
+ "Pony",
+ fields=[
+ ("id", models.AutoField(primary_key=True)),
+ ("name", models.CharField(max_length=30, unique=True)),
+ ],
+ options={"unique_together": {("name",)}},
+ ),
+ ],
+ )
+ table_name = f"{app_label}_pony"
+ unique_constraint_name = f"{table_name}_name_key"
+ unique_together_constraint_name = f"{table_name}_name_694f3b9f_uniq"
+ self.assertConstraintExists(table_name, unique_constraint_name, value=False)
+ self.assertConstraintExists(
+ table_name, unique_together_constraint_name, value=False
+ )
+
+ new_state = project_state.clone()
+ operation = migrations.AlterUniqueTogether("Pony", set())
+ operation.state_forwards(app_label, new_state)
+ with connection.schema_editor() as editor:
+ operation.database_forwards(app_label, editor, project_state, new_state)
+ self.assertConstraintExists(table_name, unique_constraint_name, value=False)
+ self.assertConstraintNotExists(table_name, unique_together_constraint_name)
+
+ def test_add_index(self):
+ """
+ Test the AddIndex operation.
+ """
+ project_state = self.set_up_test_model("test_adin")
+ msg = (
+ "Indexes passed to AddIndex operations require a name argument. "
+ " doesn't have one."
+ )
+ with self.assertRaisesMessage(ValueError, msg):
+ migrations.AddIndex("Pony", models.Index(fields=["pink"]))
+ index = models.Index(fields=["pink"], name="test_adin_pony_pink_idx")
+ operation = migrations.AddIndex("Pony", index)
+ self.assertEqual(
+ operation.describe(),
+ "Create index test_adin_pony_pink_idx on field(s) pink of model Pony",
+ )
+ self.assertEqual(
+ operation.migration_name_fragment,
+ "pony_test_adin_pony_pink_idx",
+ )
+ new_state = project_state.clone()
+ operation.state_forwards("test_adin", new_state)
+ # Test the database alteration
+ self.assertEqual(
+ len(new_state.models["test_adin", "pony"].options["indexes"]), 1
+ )
+ self.assertIndexNotExists("test_adin_pony", ["pink"])
+ with connection.schema_editor() as editor:
+ operation.database_forwards("test_adin", editor, project_state, new_state)
+ self.assertIndexExists("test_adin_pony", ["pink"])
+ # And test reversal
+ with connection.schema_editor() as editor:
+ operation.database_backwards("test_adin", editor, new_state, project_state)
+ self.assertIndexNotExists("test_adin_pony", ["pink"])
+ # And deconstruction
+ definition = operation.deconstruct()
+ self.assertEqual(definition[0], "AddIndex")
+ self.assertEqual(definition[1], [])
+ self.assertEqual(definition[2], {"model_name": "Pony", "index": index})
+
+ def test_remove_index(self):
+ """
+ Test the RemoveIndex operation.
+ """
+ project_state = self.set_up_test_model("test_rmin", multicol_index=True)
+ self.assertTableExists("test_rmin_pony")
+ self.assertIndexExists("test_rmin_pony", ["pink", "weight"])
+ operation = migrations.RemoveIndex("Pony", "pony_test_idx")
+ self.assertEqual(operation.describe(), "Remove index pony_test_idx from Pony")
+ self.assertEqual(
+ operation.migration_name_fragment,
+ "remove_pony_pony_test_idx",
+ )
+ new_state = project_state.clone()
+ operation.state_forwards("test_rmin", new_state)
+ # Test the state alteration
+ self.assertEqual(
+ len(new_state.models["test_rmin", "pony"].options["indexes"]), 0
+ )
+ self.assertIndexExists("test_rmin_pony", ["pink", "weight"])
+ # Test the database alteration
+ with connection.schema_editor() as editor:
+ operation.database_forwards("test_rmin", editor, project_state, new_state)
+ self.assertIndexNotExists("test_rmin_pony", ["pink", "weight"])
+ # And test reversal
+ with connection.schema_editor() as editor:
+ operation.database_backwards("test_rmin", editor, new_state, project_state)
+ self.assertIndexExists("test_rmin_pony", ["pink", "weight"])
+ # And deconstruction
+ definition = operation.deconstruct()
+ self.assertEqual(definition[0], "RemoveIndex")
+ self.assertEqual(definition[1], [])
+ self.assertEqual(definition[2], {"model_name": "Pony", "name": "pony_test_idx"})
+
+ # Also test a field dropped with index - sqlite remake issue
+ operations = [
+ migrations.RemoveIndex("Pony", "pony_test_idx"),
+ migrations.RemoveField("Pony", "pink"),
+ ]
+ self.assertColumnExists("test_rmin_pony", "pink")
+ self.assertIndexExists("test_rmin_pony", ["pink", "weight"])
+ # Test database alteration
+ new_state = project_state.clone()
+ self.apply_operations("test_rmin", new_state, operations=operations)
+ self.assertColumnNotExists("test_rmin_pony", "pink")
+ self.assertIndexNotExists("test_rmin_pony", ["pink", "weight"])
+ # And test reversal
+ self.unapply_operations("test_rmin", project_state, operations=operations)
+ self.assertIndexExists("test_rmin_pony", ["pink", "weight"])
+
+ def test_rename_index(self):
+ app_label = "test_rnin"
+ project_state = self.set_up_test_model(app_label, index=True)
+ table_name = app_label + "_pony"
+ self.assertIndexNameExists(table_name, "pony_pink_idx")
+ self.assertIndexNameNotExists(table_name, "new_pony_test_idx")
+ operation = migrations.RenameIndex(
+ "Pony", new_name="new_pony_test_idx", old_name="pony_pink_idx"
+ )
+ self.assertEqual(
+ operation.describe(),
+ "Rename index pony_pink_idx on Pony to new_pony_test_idx",
+ )
+ self.assertEqual(
+ operation.migration_name_fragment,
+ "rename_pony_pink_idx_new_pony_test_idx",
+ )
+
+ new_state = project_state.clone()
+ operation.state_forwards(app_label, new_state)
+ # Rename index.
+ expected_queries = 1 if connection.features.can_rename_index else 2
+ with connection.schema_editor() as editor, self.assertNumQueries(
+ expected_queries
+ ):
+ operation.database_forwards(app_label, editor, project_state, new_state)
+ self.assertIndexNameNotExists(table_name, "pony_pink_idx")
+ self.assertIndexNameExists(table_name, "new_pony_test_idx")
+ # Reversal.
+ with connection.schema_editor() as editor, self.assertNumQueries(
+ expected_queries
+ ):
+ operation.database_backwards(app_label, editor, new_state, project_state)
+ self.assertIndexNameExists(table_name, "pony_pink_idx")
+ self.assertIndexNameNotExists(table_name, "new_pony_test_idx")
+ # Deconstruction.
+ definition = operation.deconstruct()
+ self.assertEqual(definition[0], "RenameIndex")
+ self.assertEqual(definition[1], [])
+ self.assertEqual(
+ definition[2],
+ {
+ "model_name": "Pony",
+ "old_name": "pony_pink_idx",
+ "new_name": "new_pony_test_idx",
+ },
+ )
+
+ def test_rename_index_arguments(self):
+ msg = "RenameIndex.old_name and old_fields are mutually exclusive."
+ with self.assertRaisesMessage(ValueError, msg):
+ migrations.RenameIndex(
+ "Pony",
+ new_name="new_idx_name",
+ old_name="old_idx_name",
+ old_fields=("weight", "pink"),
+ )
+ msg = "RenameIndex requires one of old_name and old_fields arguments to be set."
+ with self.assertRaisesMessage(ValueError, msg):
+ migrations.RenameIndex("Pony", new_name="new_idx_name")
+
+ @ignore_warnings(category=RemovedInDjango51Warning)
+ def test_rename_index_unnamed_index(self):
+ app_label = "test_rninui"
+ project_state = self.set_up_test_model(app_label, index_together=True)
+ table_name = app_label + "_pony"
+ self.assertIndexNameNotExists(table_name, "new_pony_test_idx")
+ operation = migrations.RenameIndex(
+ "Pony", new_name="new_pony_test_idx", old_fields=("weight", "pink")
+ )
+ self.assertEqual(
+ operation.describe(),
+ "Rename unnamed index for ('weight', 'pink') on Pony to new_pony_test_idx",
+ )
+ self.assertEqual(
+ operation.migration_name_fragment,
+ "rename_pony_weight_pink_new_pony_test_idx",
+ )
+
+ new_state = project_state.clone()
+ operation.state_forwards(app_label, new_state)
+ # Rename index.
+ with connection.schema_editor() as editor:
+ operation.database_forwards(app_label, editor, project_state, new_state)
+ self.assertIndexNameExists(table_name, "new_pony_test_idx")
+ # Reverse is a no-op.
+ with connection.schema_editor() as editor, self.assertNumQueries(0):
+ operation.database_backwards(app_label, editor, new_state, project_state)
+ self.assertIndexNameExists(table_name, "new_pony_test_idx")
+ # Reapply, RenameIndex operation is a noop when the old and new name
+ # match.
+ with connection.schema_editor() as editor:
+ operation.database_forwards(app_label, editor, new_state, project_state)
+ self.assertIndexNameExists(table_name, "new_pony_test_idx")
+ # Deconstruction.
+ definition = operation.deconstruct()
+ self.assertEqual(definition[0], "RenameIndex")
+ self.assertEqual(definition[1], [])
+ self.assertEqual(
+ definition[2],
+ {
+ "model_name": "Pony",
+ "new_name": "new_pony_test_idx",
+ "old_fields": ("weight", "pink"),
+ },
+ )
+
+ def test_rename_index_unknown_unnamed_index(self):
+ app_label = "test_rninuui"
+ project_state = self.set_up_test_model(app_label)
+ operation = migrations.RenameIndex(
+ "Pony", new_name="new_pony_test_idx", old_fields=("weight", "pink")
+ )
+ new_state = project_state.clone()
+ operation.state_forwards(app_label, new_state)
+ msg = "Found wrong number (0) of indexes for test_rninuui_pony(weight, pink)."
+ with connection.schema_editor() as editor:
+ with self.assertRaisesMessage(ValueError, msg):
+ operation.database_forwards(app_label, editor, project_state, new_state)
+
+ def test_add_index_state_forwards(self):
+ project_state = self.set_up_test_model("test_adinsf")
+ index = models.Index(fields=["pink"], name="test_adinsf_pony_pink_idx")
+ old_model = project_state.apps.get_model("test_adinsf", "Pony")
+ new_state = project_state.clone()
+
+ operation = migrations.AddIndex("Pony", index)
+ operation.state_forwards("test_adinsf", new_state)
+ new_model = new_state.apps.get_model("test_adinsf", "Pony")
+ self.assertIsNot(old_model, new_model)
+
+ def test_remove_index_state_forwards(self):
+ project_state = self.set_up_test_model("test_rminsf")
+ index = models.Index(fields=["pink"], name="test_rminsf_pony_pink_idx")
+ migrations.AddIndex("Pony", index).state_forwards("test_rminsf", project_state)
+ old_model = project_state.apps.get_model("test_rminsf", "Pony")
+ new_state = project_state.clone()
+
+ operation = migrations.RemoveIndex("Pony", "test_rminsf_pony_pink_idx")
+ operation.state_forwards("test_rminsf", new_state)
+ new_model = new_state.apps.get_model("test_rminsf", "Pony")
+ self.assertIsNot(old_model, new_model)
+
+ def test_rename_index_state_forwards(self):
+ app_label = "test_rnidsf"
+ project_state = self.set_up_test_model(app_label, index=True)
+ old_model = project_state.apps.get_model(app_label, "Pony")
+ new_state = project_state.clone()
+
+ operation = migrations.RenameIndex(
+ "Pony", new_name="new_pony_pink_idx", old_name="pony_pink_idx"
+ )
+ operation.state_forwards(app_label, new_state)
+ new_model = new_state.apps.get_model(app_label, "Pony")
+ self.assertIsNot(old_model, new_model)
+ self.assertEqual(new_model._meta.indexes[0].name, "new_pony_pink_idx")
+
+ @ignore_warnings(category=RemovedInDjango51Warning)
+ def test_rename_index_state_forwards_unnamed_index(self):
+ app_label = "test_rnidsfui"
+ project_state = self.set_up_test_model(app_label, index_together=True)
+ old_model = project_state.apps.get_model(app_label, "Pony")
+ new_state = project_state.clone()
+
+ operation = migrations.RenameIndex(
+ "Pony", new_name="new_pony_pink_idx", old_fields=("weight", "pink")
+ )
+ operation.state_forwards(app_label, new_state)
+ new_model = new_state.apps.get_model(app_label, "Pony")
+ self.assertIsNot(old_model, new_model)
+ self.assertEqual(new_model._meta.index_together, tuple())
+ self.assertEqual(new_model._meta.indexes[0].name, "new_pony_pink_idx")
+
+ @skipUnlessDBFeature("supports_expression_indexes")
+ def test_add_func_index(self):
+ app_label = "test_addfuncin"
+ index_name = f"{app_label}_pony_abs_idx"
+ table_name = f"{app_label}_pony"
+ project_state = self.set_up_test_model(app_label)
+ index = models.Index(Abs("weight"), name=index_name)
+ operation = migrations.AddIndex("Pony", index)
+ self.assertEqual(
+ operation.describe(),
+ "Create index test_addfuncin_pony_abs_idx on Abs(F(weight)) on model Pony",
+ )
+ self.assertEqual(
+ operation.migration_name_fragment,
+ "pony_test_addfuncin_pony_abs_idx",
+ )
+ new_state = project_state.clone()
+ operation.state_forwards(app_label, new_state)
+ self.assertEqual(len(new_state.models[app_label, "pony"].options["indexes"]), 1)
+ self.assertIndexNameNotExists(table_name, index_name)
+ # Add index.
+ with connection.schema_editor() as editor:
+ operation.database_forwards(app_label, editor, project_state, new_state)
+ self.assertIndexNameExists(table_name, index_name)
+ # Reversal.
+ with connection.schema_editor() as editor:
+ operation.database_backwards(app_label, editor, new_state, project_state)
+ self.assertIndexNameNotExists(table_name, index_name)
+ # Deconstruction.
+ definition = operation.deconstruct()
+ self.assertEqual(definition[0], "AddIndex")
+ self.assertEqual(definition[1], [])
+ self.assertEqual(definition[2], {"model_name": "Pony", "index": index})
+
+ @skipUnlessDBFeature("supports_expression_indexes")
+ def test_remove_func_index(self):
+ app_label = "test_rmfuncin"
+ index_name = f"{app_label}_pony_abs_idx"
+ table_name = f"{app_label}_pony"
+ project_state = self.set_up_test_model(
+ app_label,
+ indexes=[
+ models.Index(Abs("weight"), name=index_name),
+ ],
+ )
+ self.assertTableExists(table_name)
+ self.assertIndexNameExists(table_name, index_name)
+ operation = migrations.RemoveIndex("Pony", index_name)
+ self.assertEqual(
+ operation.describe(),
+ "Remove index test_rmfuncin_pony_abs_idx from Pony",
+ )
+ self.assertEqual(
+ operation.migration_name_fragment,
+ "remove_pony_test_rmfuncin_pony_abs_idx",
+ )
+ new_state = project_state.clone()
+ operation.state_forwards(app_label, new_state)
+ self.assertEqual(len(new_state.models[app_label, "pony"].options["indexes"]), 0)
+ # Remove index.
+ with connection.schema_editor() as editor:
+ operation.database_forwards(app_label, editor, project_state, new_state)
+ self.assertIndexNameNotExists(table_name, index_name)
+ # Reversal.
+ with connection.schema_editor() as editor:
+ operation.database_backwards(app_label, editor, new_state, project_state)
+ self.assertIndexNameExists(table_name, index_name)
+ # Deconstruction.
+ definition = operation.deconstruct()
+ self.assertEqual(definition[0], "RemoveIndex")
+ self.assertEqual(definition[1], [])
+ self.assertEqual(definition[2], {"model_name": "Pony", "name": index_name})
+
+ @skipUnlessDBFeature("supports_expression_indexes")
+ def test_alter_field_with_func_index(self):
+ app_label = "test_alfuncin"
+ index_name = f"{app_label}_pony_idx"
+ table_name = f"{app_label}_pony"
+ project_state = self.set_up_test_model(
+ app_label,
+ indexes=[models.Index(Abs("pink"), name=index_name)],
+ )
+ operation = migrations.AlterField(
+ "Pony", "pink", models.IntegerField(null=True)
+ )
+ new_state = project_state.clone()
+ operation.state_forwards(app_label, new_state)
+ with connection.schema_editor() as editor:
+ operation.database_forwards(app_label, editor, project_state, new_state)
+ self.assertIndexNameExists(table_name, index_name)
+ with connection.schema_editor() as editor:
+ operation.database_backwards(app_label, editor, new_state, project_state)
+ self.assertIndexNameExists(table_name, index_name)
+
+ def test_alter_field_with_index(self):
+ """
+ Test AlterField operation with an index to ensure indexes created via
+ Meta.indexes don't get dropped with sqlite3 remake.
+ """
+ project_state = self.set_up_test_model("test_alflin", index=True)
+ operation = migrations.AlterField(
+ "Pony", "pink", models.IntegerField(null=True)
+ )
+ new_state = project_state.clone()
+ operation.state_forwards("test_alflin", new_state)
+ # Test the database alteration
+ self.assertColumnNotNull("test_alflin_pony", "pink")
+ with connection.schema_editor() as editor:
+ operation.database_forwards("test_alflin", editor, project_state, new_state)
+ # Index hasn't been dropped
+ self.assertIndexExists("test_alflin_pony", ["pink"])
+ # And test reversal
+ with connection.schema_editor() as editor:
+ operation.database_backwards(
+ "test_alflin", editor, new_state, project_state
+ )
+ # Ensure the index is still there
+ self.assertIndexExists("test_alflin_pony", ["pink"])
+
+ @ignore_warnings(category=RemovedInDjango51Warning)
+ def test_alter_index_together(self):
+ """
+ Tests the AlterIndexTogether operation.
+ """
+ project_state = self.set_up_test_model("test_alinto")
+ # Test the state alteration
+ operation = migrations.AlterIndexTogether("Pony", [("pink", "weight")])
+ self.assertEqual(
+ operation.describe(), "Alter index_together for Pony (1 constraint(s))"
+ )
+ self.assertEqual(
+ operation.migration_name_fragment,
+ "alter_pony_index_together",
+ )
+ new_state = project_state.clone()
+ operation.state_forwards("test_alinto", new_state)
+ self.assertEqual(
+ len(
+ project_state.models["test_alinto", "pony"].options.get(
+ "index_together", set()
+ )
+ ),
+ 0,
+ )
+ self.assertEqual(
+ len(
+ new_state.models["test_alinto", "pony"].options.get(
+ "index_together", set()
+ )
+ ),
+ 1,
+ )
+ # Make sure there's no matching index
+ self.assertIndexNotExists("test_alinto_pony", ["pink", "weight"])
+ # Test the database alteration
+ with connection.schema_editor() as editor:
+ operation.database_forwards("test_alinto", editor, project_state, new_state)
+ self.assertIndexExists("test_alinto_pony", ["pink", "weight"])
+ # And test reversal
+ with connection.schema_editor() as editor:
+ operation.database_backwards(
+ "test_alinto", editor, new_state, project_state
+ )
+ self.assertIndexNotExists("test_alinto_pony", ["pink", "weight"])
+ # And deconstruction
+ definition = operation.deconstruct()
+ self.assertEqual(definition[0], "AlterIndexTogether")
+ self.assertEqual(definition[1], [])
+ self.assertEqual(
+ definition[2], {"name": "Pony", "index_together": {("pink", "weight")}}
+ )
+
+ def test_alter_index_together_remove(self):
+ operation = migrations.AlterIndexTogether("Pony", None)
+ self.assertEqual(
+ operation.describe(), "Alter index_together for Pony (0 constraint(s))"
+ )
+
+ @skipUnlessDBFeature("allows_multiple_constraints_on_same_fields")
+ @ignore_warnings(category=RemovedInDjango51Warning)
+ def test_alter_index_together_remove_with_unique_together(self):
+ app_label = "test_alintoremove_wunto"
+ table_name = "%s_pony" % app_label
+ project_state = self.set_up_test_model(app_label, unique_together=True)
+ self.assertUniqueConstraintExists(table_name, ["pink", "weight"])
+ # Add index together.
+ new_state = project_state.clone()
+ operation = migrations.AlterIndexTogether("Pony", [("pink", "weight")])
+ operation.state_forwards(app_label, new_state)
+ with connection.schema_editor() as editor:
+ operation.database_forwards(app_label, editor, project_state, new_state)
+ self.assertIndexExists(table_name, ["pink", "weight"])
+ # Remove index together.
+ project_state = new_state
+ new_state = project_state.clone()
+ operation = migrations.AlterIndexTogether("Pony", set())
+ operation.state_forwards(app_label, new_state)
+ with connection.schema_editor() as editor:
+ operation.database_forwards(app_label, editor, project_state, new_state)
+ self.assertIndexNotExists(table_name, ["pink", "weight"])
+ self.assertUniqueConstraintExists(table_name, ["pink", "weight"])
+
+ def test_add_constraint(self):
+ project_state = self.set_up_test_model("test_addconstraint")
+ gt_check = models.Q(pink__gt=2)
+ gt_constraint = models.CheckConstraint(
+ check=gt_check, name="test_add_constraint_pony_pink_gt_2"
+ )
+ gt_operation = migrations.AddConstraint("Pony", gt_constraint)
+ self.assertEqual(
+ gt_operation.describe(),
+ "Create constraint test_add_constraint_pony_pink_gt_2 on model Pony",
+ )
+ self.assertEqual(
+ gt_operation.migration_name_fragment,
+ "pony_test_add_constraint_pony_pink_gt_2",
+ )
+ # Test the state alteration
+ new_state = project_state.clone()
+ gt_operation.state_forwards("test_addconstraint", new_state)
+ self.assertEqual(
+ len(new_state.models["test_addconstraint", "pony"].options["constraints"]),
+ 1,
+ )
+ Pony = new_state.apps.get_model("test_addconstraint", "Pony")
+ self.assertEqual(len(Pony._meta.constraints), 1)
+ # Test the database alteration
+ with (
+ CaptureQueriesContext(connection) as ctx,
+ connection.schema_editor() as editor,
+ ):
+ gt_operation.database_forwards(
+ "test_addconstraint", editor, project_state, new_state
+ )
+ if connection.features.supports_table_check_constraints:
+ with self.assertRaises(IntegrityError), transaction.atomic():
+ Pony.objects.create(pink=1, weight=1.0)
+ else:
+ self.assertIs(
+ any("CHECK" in query["sql"] for query in ctx.captured_queries), False
+ )
+ Pony.objects.create(pink=1, weight=1.0)
+ # Add another one.
+ lt_check = models.Q(pink__lt=100)
+ lt_constraint = models.CheckConstraint(
+ check=lt_check, name="test_add_constraint_pony_pink_lt_100"
+ )
+ lt_operation = migrations.AddConstraint("Pony", lt_constraint)
+ lt_operation.state_forwards("test_addconstraint", new_state)
+ self.assertEqual(
+ len(new_state.models["test_addconstraint", "pony"].options["constraints"]),
+ 2,
+ )
+ Pony = new_state.apps.get_model("test_addconstraint", "Pony")
+ self.assertEqual(len(Pony._meta.constraints), 2)
+ with (
+ CaptureQueriesContext(connection) as ctx,
+ connection.schema_editor() as editor,
+ ):
+ lt_operation.database_forwards(
+ "test_addconstraint", editor, project_state, new_state
+ )
+ if connection.features.supports_table_check_constraints:
+ with self.assertRaises(IntegrityError), transaction.atomic():
+ Pony.objects.create(pink=100, weight=1.0)
+ else:
+ self.assertIs(
+ any("CHECK" in query["sql"] for query in ctx.captured_queries), False
+ )
+ Pony.objects.create(pink=100, weight=1.0)
+ # Test reversal
+ with connection.schema_editor() as editor:
+ gt_operation.database_backwards(
+ "test_addconstraint", editor, new_state, project_state
+ )
+ Pony.objects.create(pink=1, weight=1.0)
+ # Test deconstruction
+ definition = gt_operation.deconstruct()
+ self.assertEqual(definition[0], "AddConstraint")
+ self.assertEqual(definition[1], [])
+ self.assertEqual(
+ definition[2], {"model_name": "Pony", "constraint": gt_constraint}
+ )
+
+ @skipUnlessDBFeature("supports_table_check_constraints")
+ def test_add_constraint_percent_escaping(self):
+ app_label = "add_constraint_string_quoting"
+ operations = [
+ migrations.CreateModel(
+ "Author",
+ fields=[
+ ("id", models.AutoField(primary_key=True)),
+ ("name", models.CharField(max_length=100)),
+ ("surname", models.CharField(max_length=100, default="")),
+ ("rebate", models.CharField(max_length=100)),
+ ],
+ ),
+ ]
+ from_state = self.apply_operations(app_label, ProjectState(), operations)
+ checks = [
+ # "%" generated in startswith lookup should be escaped in a way
+ # that is considered a leading wildcard.
+ (
+ models.Q(name__startswith="Albert"),
+ {"name": "Alberta"},
+ {"name": "Artur"},
+ ),
+ # Literal "%" should be escaped in a way that is not a considered a
+ # wildcard.
+ (models.Q(rebate__endswith="%"), {"rebate": "10%"}, {"rebate": "10%$"}),
+ # Right-hand-side baked "%" literals should not be used for
+ # parameters interpolation.
+ (
+ ~models.Q(surname__startswith=models.F("name")),
+ {"name": "Albert"},
+ {"name": "Albert", "surname": "Alberto"},
+ ),
+ # Exact matches against "%" literals should also be supported.
+ (
+ models.Q(name="%"),
+ {"name": "%"},
+ {"name": "Albert"},
+ ),
+ ]
+ for check, valid, invalid in checks:
+ with self.subTest(check=check, valid=valid, invalid=invalid):
+ constraint = models.CheckConstraint(check=check, name="constraint")
+ operation = migrations.AddConstraint("Author", constraint)
+ to_state = from_state.clone()
+ operation.state_forwards(app_label, to_state)
+ with connection.schema_editor() as editor:
+ operation.database_forwards(app_label, editor, from_state, to_state)
+ Author = to_state.apps.get_model(app_label, "Author")
+ try:
+ with transaction.atomic():
+ Author.objects.create(**valid).delete()
+ with self.assertRaises(IntegrityError), transaction.atomic():
+ Author.objects.create(**invalid)
+ finally:
+ with connection.schema_editor() as editor:
+ operation.database_backwards(
+ app_label, editor, from_state, to_state
+ )
+
+ @skipUnlessDBFeature("supports_table_check_constraints")
+ def test_add_or_constraint(self):
+ app_label = "test_addorconstraint"
+ constraint_name = "add_constraint_or"
+ from_state = self.set_up_test_model(app_label)
+ check = models.Q(pink__gt=2, weight__gt=2) | models.Q(weight__lt=0)
+ constraint = models.CheckConstraint(check=check, name=constraint_name)
+ operation = migrations.AddConstraint("Pony", constraint)
+ to_state = from_state.clone()
+ operation.state_forwards(app_label, to_state)
+ with connection.schema_editor() as editor:
+ operation.database_forwards(app_label, editor, from_state, to_state)
+ Pony = to_state.apps.get_model(app_label, "Pony")
+ with self.assertRaises(IntegrityError), transaction.atomic():
+ Pony.objects.create(pink=2, weight=3.0)
+ with self.assertRaises(IntegrityError), transaction.atomic():
+ Pony.objects.create(pink=3, weight=1.0)
+ Pony.objects.bulk_create(
+ [
+ Pony(pink=3, weight=-1.0),
+ Pony(pink=1, weight=-1.0),
+ Pony(pink=3, weight=3.0),
+ ]
+ )
+
+ @skipUnlessDBFeature("supports_table_check_constraints")
+ def test_add_constraint_combinable(self):
+ app_label = "test_addconstraint_combinable"
+ operations = [
+ migrations.CreateModel(
+ "Book",
+ fields=[
+ ("id", models.AutoField(primary_key=True)),
+ ("read", models.PositiveIntegerField()),
+ ("unread", models.PositiveIntegerField()),
+ ],
+ ),
+ ]
+ from_state = self.apply_operations(app_label, ProjectState(), operations)
+ constraint = models.CheckConstraint(
+ check=models.Q(read=(100 - models.F("unread"))),
+ name="test_addconstraint_combinable_sum_100",
+ )
+ operation = migrations.AddConstraint("Book", constraint)
+ to_state = from_state.clone()
+ operation.state_forwards(app_label, to_state)
+ with connection.schema_editor() as editor:
+ operation.database_forwards(app_label, editor, from_state, to_state)
+ Book = to_state.apps.get_model(app_label, "Book")
+ with self.assertRaises(IntegrityError), transaction.atomic():
+ Book.objects.create(read=70, unread=10)
+ Book.objects.create(read=70, unread=30)
+
+ def test_remove_constraint(self):
+ project_state = self.set_up_test_model(
+ "test_removeconstraint",
+ constraints=[
+ models.CheckConstraint(
+ check=models.Q(pink__gt=2),
+ name="test_remove_constraint_pony_pink_gt_2",
+ ),
+ models.CheckConstraint(
+ check=models.Q(pink__lt=100),
+ name="test_remove_constraint_pony_pink_lt_100",
+ ),
+ ],
+ )
+ gt_operation = migrations.RemoveConstraint(
+ "Pony", "test_remove_constraint_pony_pink_gt_2"
+ )
+ self.assertEqual(
+ gt_operation.describe(),
+ "Remove constraint test_remove_constraint_pony_pink_gt_2 from model Pony",
+ )
+ self.assertEqual(
+ gt_operation.migration_name_fragment,
+ "remove_pony_test_remove_constraint_pony_pink_gt_2",
+ )
+ # Test state alteration
+ new_state = project_state.clone()
+ gt_operation.state_forwards("test_removeconstraint", new_state)
+ self.assertEqual(
+ len(
+ new_state.models["test_removeconstraint", "pony"].options["constraints"]
+ ),
+ 1,
+ )
+ Pony = new_state.apps.get_model("test_removeconstraint", "Pony")
+ self.assertEqual(len(Pony._meta.constraints), 1)
+ # Test database alteration
+ with connection.schema_editor() as editor:
+ gt_operation.database_forwards(
+ "test_removeconstraint", editor, project_state, new_state
+ )
+ Pony.objects.create(pink=1, weight=1.0).delete()
+ if connection.features.supports_table_check_constraints:
+ with self.assertRaises(IntegrityError), transaction.atomic():
+ Pony.objects.create(pink=100, weight=1.0)
+ else:
+ Pony.objects.create(pink=100, weight=1.0)
+ # Remove the other one.
+ lt_operation = migrations.RemoveConstraint(
+ "Pony", "test_remove_constraint_pony_pink_lt_100"
+ )
+ lt_operation.state_forwards("test_removeconstraint", new_state)
+ self.assertEqual(
+ len(
+ new_state.models["test_removeconstraint", "pony"].options["constraints"]
+ ),
+ 0,
+ )
+ Pony = new_state.apps.get_model("test_removeconstraint", "Pony")
+ self.assertEqual(len(Pony._meta.constraints), 0)
+ with connection.schema_editor() as editor:
+ lt_operation.database_forwards(
+ "test_removeconstraint", editor, project_state, new_state
+ )
+ Pony.objects.create(pink=100, weight=1.0).delete()
+ # Test reversal
+ with connection.schema_editor() as editor:
+ gt_operation.database_backwards(
+ "test_removeconstraint", editor, new_state, project_state
+ )
+ if connection.features.supports_table_check_constraints:
+ with self.assertRaises(IntegrityError), transaction.atomic():
+ Pony.objects.create(pink=1, weight=1.0)
+ else:
+ Pony.objects.create(pink=1, weight=1.0)
+ # Test deconstruction
+ definition = gt_operation.deconstruct()
+ self.assertEqual(definition[0], "RemoveConstraint")
+ self.assertEqual(definition[1], [])
+ self.assertEqual(
+ definition[2],
+ {"model_name": "Pony", "name": "test_remove_constraint_pony_pink_gt_2"},
+ )
+
+ def test_add_partial_unique_constraint(self):
+ project_state = self.set_up_test_model("test_addpartialuniqueconstraint")
+ partial_unique_constraint = models.UniqueConstraint(
+ fields=["pink"],
+ condition=models.Q(weight__gt=5),
+ name="test_constraint_pony_pink_for_weight_gt_5_uniq",
+ )
+ operation = migrations.AddConstraint("Pony", partial_unique_constraint)
+ self.assertEqual(
+ operation.describe(),
+ "Create constraint test_constraint_pony_pink_for_weight_gt_5_uniq "
+ "on model Pony",
+ )
+ # Test the state alteration
+ new_state = project_state.clone()
+ operation.state_forwards("test_addpartialuniqueconstraint", new_state)
+ self.assertEqual(
+ len(
+ new_state.models["test_addpartialuniqueconstraint", "pony"].options[
+ "constraints"
+ ]
+ ),
+ 1,
+ )
+ Pony = new_state.apps.get_model("test_addpartialuniqueconstraint", "Pony")
+ self.assertEqual(len(Pony._meta.constraints), 1)
+ # Test the database alteration
+ with connection.schema_editor() as editor:
+ operation.database_forwards(
+ "test_addpartialuniqueconstraint", editor, project_state, new_state
+ )
+ # Test constraint works
+ Pony.objects.create(pink=1, weight=4.0)
+ Pony.objects.create(pink=1, weight=4.0)
+ Pony.objects.create(pink=1, weight=6.0)
+ if connection.features.supports_partial_indexes:
+ with self.assertRaises(IntegrityError), transaction.atomic():
+ Pony.objects.create(pink=1, weight=7.0)
+ else:
+ Pony.objects.create(pink=1, weight=7.0)
+ # Test reversal
+ with connection.schema_editor() as editor:
+ operation.database_backwards(
+ "test_addpartialuniqueconstraint", editor, new_state, project_state
+ )
+ # Test constraint doesn't work
+ Pony.objects.create(pink=1, weight=7.0)
+ # Test deconstruction
+ definition = operation.deconstruct()
+ self.assertEqual(definition[0], "AddConstraint")
+ self.assertEqual(definition[1], [])
+ self.assertEqual(
+ definition[2],
+ {"model_name": "Pony", "constraint": partial_unique_constraint},
+ )
+
+ def test_remove_partial_unique_constraint(self):
+ project_state = self.set_up_test_model(
+ "test_removepartialuniqueconstraint",
+ constraints=[
+ models.UniqueConstraint(
+ fields=["pink"],
+ condition=models.Q(weight__gt=5),
+ name="test_constraint_pony_pink_for_weight_gt_5_uniq",
+ ),
+ ],
+ )
+ gt_operation = migrations.RemoveConstraint(
+ "Pony", "test_constraint_pony_pink_for_weight_gt_5_uniq"
+ )
+ self.assertEqual(
+ gt_operation.describe(),
+ "Remove constraint test_constraint_pony_pink_for_weight_gt_5_uniq from "
+ "model Pony",
+ )
+ # Test state alteration
+ new_state = project_state.clone()
+ gt_operation.state_forwards("test_removepartialuniqueconstraint", new_state)
+ self.assertEqual(
+ len(
+ new_state.models["test_removepartialuniqueconstraint", "pony"].options[
+ "constraints"
+ ]
+ ),
+ 0,
+ )
+ Pony = new_state.apps.get_model("test_removepartialuniqueconstraint", "Pony")
+ self.assertEqual(len(Pony._meta.constraints), 0)
+ # Test database alteration
+ with connection.schema_editor() as editor:
+ gt_operation.database_forwards(
+ "test_removepartialuniqueconstraint", editor, project_state, new_state
+ )
+ # Test constraint doesn't work
+ Pony.objects.create(pink=1, weight=4.0)
+ Pony.objects.create(pink=1, weight=4.0)
+ Pony.objects.create(pink=1, weight=6.0)
+ Pony.objects.create(pink=1, weight=7.0).delete()
+ # Test reversal
+ with connection.schema_editor() as editor:
+ gt_operation.database_backwards(
+ "test_removepartialuniqueconstraint", editor, new_state, project_state
+ )
+ # Test constraint works
+ if connection.features.supports_partial_indexes:
+ with self.assertRaises(IntegrityError), transaction.atomic():
+ Pony.objects.create(pink=1, weight=7.0)
+ else:
+ Pony.objects.create(pink=1, weight=7.0)
+ # Test deconstruction
+ definition = gt_operation.deconstruct()
+ self.assertEqual(definition[0], "RemoveConstraint")
+ self.assertEqual(definition[1], [])
+ self.assertEqual(
+ definition[2],
+ {
+ "model_name": "Pony",
+ "name": "test_constraint_pony_pink_for_weight_gt_5_uniq",
+ },
+ )
+
+ def test_add_deferred_unique_constraint(self):
+ app_label = "test_adddeferred_uc"
+ project_state = self.set_up_test_model(app_label)
+ deferred_unique_constraint = models.UniqueConstraint(
+ fields=["pink"],
+ name="deferred_pink_constraint_add",
+ deferrable=models.Deferrable.DEFERRED,
+ )
+ operation = migrations.AddConstraint("Pony", deferred_unique_constraint)
+ self.assertEqual(
+ operation.describe(),
+ "Create constraint deferred_pink_constraint_add on model Pony",
+ )
+ # Add constraint.
+ new_state = project_state.clone()
+ operation.state_forwards(app_label, new_state)
+ self.assertEqual(
+ len(new_state.models[app_label, "pony"].options["constraints"]), 1
+ )
+ Pony = new_state.apps.get_model(app_label, "Pony")
+ self.assertEqual(len(Pony._meta.constraints), 1)
+ with connection.schema_editor() as editor, CaptureQueriesContext(
+ connection
+ ) as ctx:
+ operation.database_forwards(app_label, editor, project_state, new_state)
+ Pony.objects.create(pink=1, weight=4.0)
+ if connection.features.supports_deferrable_unique_constraints:
+ # Unique constraint is deferred.
+ with transaction.atomic():
+ obj = Pony.objects.create(pink=1, weight=4.0)
+ obj.pink = 2
+ obj.save()
+ # Constraint behavior can be changed with SET CONSTRAINTS.
+ with self.assertRaises(IntegrityError):
+ with transaction.atomic(), connection.cursor() as cursor:
+ quoted_name = connection.ops.quote_name(
+ deferred_unique_constraint.name
+ )
+ cursor.execute("SET CONSTRAINTS %s IMMEDIATE" % quoted_name)
+ obj = Pony.objects.create(pink=1, weight=4.0)
+ obj.pink = 3
+ obj.save()
+ else:
+ self.assertEqual(len(ctx), 0)
+ Pony.objects.create(pink=1, weight=4.0)
+ # Reversal.
+ with connection.schema_editor() as editor:
+ operation.database_backwards(app_label, editor, new_state, project_state)
+ # Constraint doesn't work.
+ Pony.objects.create(pink=1, weight=4.0)
+ # Deconstruction.
+ definition = operation.deconstruct()
+ self.assertEqual(definition[0], "AddConstraint")
+ self.assertEqual(definition[1], [])
+ self.assertEqual(
+ definition[2],
+ {"model_name": "Pony", "constraint": deferred_unique_constraint},
+ )
+
+ def test_remove_deferred_unique_constraint(self):
+ app_label = "test_removedeferred_uc"
+ deferred_unique_constraint = models.UniqueConstraint(
+ fields=["pink"],
+ name="deferred_pink_constraint_rm",
+ deferrable=models.Deferrable.DEFERRED,
+ )
+ project_state = self.set_up_test_model(
+ app_label, constraints=[deferred_unique_constraint]
+ )
+ operation = migrations.RemoveConstraint("Pony", deferred_unique_constraint.name)
+ self.assertEqual(
+ operation.describe(),
+ "Remove constraint deferred_pink_constraint_rm from model Pony",
+ )
+ # Remove constraint.
+ new_state = project_state.clone()
+ operation.state_forwards(app_label, new_state)
+ self.assertEqual(
+ len(new_state.models[app_label, "pony"].options["constraints"]), 0
+ )
+ Pony = new_state.apps.get_model(app_label, "Pony")
+ self.assertEqual(len(Pony._meta.constraints), 0)
+ with connection.schema_editor() as editor, CaptureQueriesContext(
+ connection
+ ) as ctx:
+ operation.database_forwards(app_label, editor, project_state, new_state)
+ # Constraint doesn't work.
+ Pony.objects.create(pink=1, weight=4.0)
+ Pony.objects.create(pink=1, weight=4.0).delete()
+ if not connection.features.supports_deferrable_unique_constraints:
+ self.assertEqual(len(ctx), 0)
+ # Reversal.
+ with connection.schema_editor() as editor:
+ operation.database_backwards(app_label, editor, new_state, project_state)
+ if connection.features.supports_deferrable_unique_constraints:
+ # Unique constraint is deferred.
+ with transaction.atomic():
+ obj = Pony.objects.create(pink=1, weight=4.0)
+ obj.pink = 2
+ obj.save()
+ # Constraint behavior can be changed with SET CONSTRAINTS.
+ with self.assertRaises(IntegrityError):
+ with transaction.atomic(), connection.cursor() as cursor:
+ quoted_name = connection.ops.quote_name(
+ deferred_unique_constraint.name
+ )
+ cursor.execute("SET CONSTRAINTS %s IMMEDIATE" % quoted_name)
+ obj = Pony.objects.create(pink=1, weight=4.0)
+ obj.pink = 3
+ obj.save()
+ else:
+ Pony.objects.create(pink=1, weight=4.0)
+ # Deconstruction.
+ definition = operation.deconstruct()
+ self.assertEqual(definition[0], "RemoveConstraint")
+ self.assertEqual(definition[1], [])
+ self.assertEqual(
+ definition[2],
+ {
+ "model_name": "Pony",
+ "name": "deferred_pink_constraint_rm",
+ },
+ )
+
+ def test_add_covering_unique_constraint(self):
+ app_label = "test_addcovering_uc"
+ project_state = self.set_up_test_model(app_label)
+ covering_unique_constraint = models.UniqueConstraint(
+ fields=["pink"],
+ name="covering_pink_constraint_add",
+ include=["weight"],
+ )
+ operation = migrations.AddConstraint("Pony", covering_unique_constraint)
+ self.assertEqual(
+ operation.describe(),
+ "Create constraint covering_pink_constraint_add on model Pony",
+ )
+ # Add constraint.
+ new_state = project_state.clone()
+ operation.state_forwards(app_label, new_state)
+ self.assertEqual(
+ len(new_state.models[app_label, "pony"].options["constraints"]), 1
+ )
+ Pony = new_state.apps.get_model(app_label, "Pony")
+ self.assertEqual(len(Pony._meta.constraints), 1)
+ with connection.schema_editor() as editor, CaptureQueriesContext(
+ connection
+ ) as ctx:
+ operation.database_forwards(app_label, editor, project_state, new_state)
+ Pony.objects.create(pink=1, weight=4.0)
+ if connection.features.supports_covering_indexes:
+ with self.assertRaises(IntegrityError):
+ Pony.objects.create(pink=1, weight=4.0)
+ else:
+ self.assertEqual(len(ctx), 0)
+ Pony.objects.create(pink=1, weight=4.0)
+ # Reversal.
+ with connection.schema_editor() as editor:
+ operation.database_backwards(app_label, editor, new_state, project_state)
+ # Constraint doesn't work.
+ Pony.objects.create(pink=1, weight=4.0)
+ # Deconstruction.
+ definition = operation.deconstruct()
+ self.assertEqual(definition[0], "AddConstraint")
+ self.assertEqual(definition[1], [])
+ self.assertEqual(
+ definition[2],
+ {"model_name": "Pony", "constraint": covering_unique_constraint},
+ )
+
+ def test_remove_covering_unique_constraint(self):
+ app_label = "test_removecovering_uc"
+ covering_unique_constraint = models.UniqueConstraint(
+ fields=["pink"],
+ name="covering_pink_constraint_rm",
+ include=["weight"],
+ )
+ project_state = self.set_up_test_model(
+ app_label, constraints=[covering_unique_constraint]
+ )
+ operation = migrations.RemoveConstraint("Pony", covering_unique_constraint.name)
+ self.assertEqual(
+ operation.describe(),
+ "Remove constraint covering_pink_constraint_rm from model Pony",
+ )
+ # Remove constraint.
+ new_state = project_state.clone()
+ operation.state_forwards(app_label, new_state)
+ self.assertEqual(
+ len(new_state.models[app_label, "pony"].options["constraints"]), 0
+ )
+ Pony = new_state.apps.get_model(app_label, "Pony")
+ self.assertEqual(len(Pony._meta.constraints), 0)
+ with connection.schema_editor() as editor, CaptureQueriesContext(
+ connection
+ ) as ctx:
+ operation.database_forwards(app_label, editor, project_state, new_state)
+ # Constraint doesn't work.
+ Pony.objects.create(pink=1, weight=4.0)
+ Pony.objects.create(pink=1, weight=4.0).delete()
+ if not connection.features.supports_covering_indexes:
+ self.assertEqual(len(ctx), 0)
+ # Reversal.
+ with connection.schema_editor() as editor:
+ operation.database_backwards(app_label, editor, new_state, project_state)
+ if connection.features.supports_covering_indexes:
+ with self.assertRaises(IntegrityError):
+ Pony.objects.create(pink=1, weight=4.0)
+ else:
+ Pony.objects.create(pink=1, weight=4.0)
+ # Deconstruction.
+ definition = operation.deconstruct()
+ self.assertEqual(definition[0], "RemoveConstraint")
+ self.assertEqual(definition[1], [])
+ self.assertEqual(
+ definition[2],
+ {
+ "model_name": "Pony",
+ "name": "covering_pink_constraint_rm",
+ },
+ )
+
+ def test_alter_field_with_func_unique_constraint(self):
+ app_label = "test_alfuncuc"
+ constraint_name = f"{app_label}_pony_uq"
+ table_name = f"{app_label}_pony"
+ project_state = self.set_up_test_model(
+ app_label,
+ constraints=[
+ models.UniqueConstraint("pink", "weight", name=constraint_name)
+ ],
+ )
+ operation = migrations.AlterField(
+ "Pony", "pink", models.IntegerField(null=True)
+ )
+ new_state = project_state.clone()
+ operation.state_forwards(app_label, new_state)
+ with connection.schema_editor() as editor:
+ operation.database_forwards(app_label, editor, project_state, new_state)
+ if connection.features.supports_expression_indexes:
+ self.assertIndexNameExists(table_name, constraint_name)
+ with connection.schema_editor() as editor:
+ operation.database_backwards(app_label, editor, new_state, project_state)
+ if connection.features.supports_expression_indexes:
+ self.assertIndexNameExists(table_name, constraint_name)
+
+ def test_add_func_unique_constraint(self):
+ app_label = "test_adfuncuc"
+ constraint_name = f"{app_label}_pony_abs_uq"
+ table_name = f"{app_label}_pony"
+ project_state = self.set_up_test_model(app_label)
+ constraint = models.UniqueConstraint(Abs("weight"), name=constraint_name)
+ operation = migrations.AddConstraint("Pony", constraint)
+ self.assertEqual(
+ operation.describe(),
+ "Create constraint test_adfuncuc_pony_abs_uq on model Pony",
+ )
+ self.assertEqual(
+ operation.migration_name_fragment,
+ "pony_test_adfuncuc_pony_abs_uq",
+ )
+ new_state = project_state.clone()
+ operation.state_forwards(app_label, new_state)
+ self.assertEqual(
+ len(new_state.models[app_label, "pony"].options["constraints"]), 1
+ )
+ self.assertIndexNameNotExists(table_name, constraint_name)
+ # Add constraint.
+ with connection.schema_editor() as editor:
+ operation.database_forwards(app_label, editor, project_state, new_state)
+ Pony = new_state.apps.get_model(app_label, "Pony")
+ Pony.objects.create(weight=4.0)
+ if connection.features.supports_expression_indexes:
+ self.assertIndexNameExists(table_name, constraint_name)
+ with self.assertRaises(IntegrityError):
+ Pony.objects.create(weight=-4.0)
+ else:
+ self.assertIndexNameNotExists(table_name, constraint_name)
+ Pony.objects.create(weight=-4.0)
+ # Reversal.
+ with connection.schema_editor() as editor:
+ operation.database_backwards(app_label, editor, new_state, project_state)
+ self.assertIndexNameNotExists(table_name, constraint_name)
+ # Constraint doesn't work.
+ Pony.objects.create(weight=-4.0)
+ # Deconstruction.
+ definition = operation.deconstruct()
+ self.assertEqual(definition[0], "AddConstraint")
+ self.assertEqual(definition[1], [])
+ self.assertEqual(
+ definition[2],
+ {"model_name": "Pony", "constraint": constraint},
+ )
+
+ def test_remove_func_unique_constraint(self):
+ app_label = "test_rmfuncuc"
+ constraint_name = f"{app_label}_pony_abs_uq"
+ table_name = f"{app_label}_pony"
+ project_state = self.set_up_test_model(
+ app_label,
+ constraints=[
+ models.UniqueConstraint(Abs("weight"), name=constraint_name),
+ ],
+ )
+ self.assertTableExists(table_name)
+ if connection.features.supports_expression_indexes:
+ self.assertIndexNameExists(table_name, constraint_name)
+ operation = migrations.RemoveConstraint("Pony", constraint_name)
+ self.assertEqual(
+ operation.describe(),
+ "Remove constraint test_rmfuncuc_pony_abs_uq from model Pony",
+ )
+ self.assertEqual(
+ operation.migration_name_fragment,
+ "remove_pony_test_rmfuncuc_pony_abs_uq",
+ )
+ new_state = project_state.clone()
+ operation.state_forwards(app_label, new_state)
+ self.assertEqual(
+ len(new_state.models[app_label, "pony"].options["constraints"]), 0
+ )
+ Pony = new_state.apps.get_model(app_label, "Pony")
+ self.assertEqual(len(Pony._meta.constraints), 0)
+ # Remove constraint.
+ with connection.schema_editor() as editor:
+ operation.database_forwards(app_label, editor, project_state, new_state)
+ self.assertIndexNameNotExists(table_name, constraint_name)
+ # Constraint doesn't work.
+ Pony.objects.create(pink=1, weight=4.0)
+ Pony.objects.create(pink=1, weight=-4.0).delete()
+ # Reversal.
+ with connection.schema_editor() as editor:
+ operation.database_backwards(app_label, editor, new_state, project_state)
+ if connection.features.supports_expression_indexes:
+ self.assertIndexNameExists(table_name, constraint_name)
+ with self.assertRaises(IntegrityError):
+ Pony.objects.create(weight=-4.0)
+ else:
+ self.assertIndexNameNotExists(table_name, constraint_name)
+ Pony.objects.create(weight=-4.0)
+ # Deconstruction.
+ definition = operation.deconstruct()
+ self.assertEqual(definition[0], "RemoveConstraint")
+ self.assertEqual(definition[1], [])
+ self.assertEqual(definition[2], {"model_name": "Pony", "name": constraint_name})
+
+ def test_alter_model_options(self):
+ """
+ Tests the AlterModelOptions operation.
+ """
+ project_state = self.set_up_test_model("test_almoop")
+ # Test the state alteration (no DB alteration to test)
+ operation = migrations.AlterModelOptions(
+ "Pony", {"permissions": [("can_groom", "Can groom")]}
+ )
+ self.assertEqual(operation.describe(), "Change Meta options on Pony")
+ self.assertEqual(operation.migration_name_fragment, "alter_pony_options")
+ new_state = project_state.clone()
+ operation.state_forwards("test_almoop", new_state)
+ self.assertEqual(
+ len(
+ project_state.models["test_almoop", "pony"].options.get(
+ "permissions", []
+ )
+ ),
+ 0,
+ )
+ self.assertEqual(
+ len(new_state.models["test_almoop", "pony"].options.get("permissions", [])),
+ 1,
+ )
+ self.assertEqual(
+ new_state.models["test_almoop", "pony"].options["permissions"][0][0],
+ "can_groom",
+ )
+ # And deconstruction
+ definition = operation.deconstruct()
+ self.assertEqual(definition[0], "AlterModelOptions")
+ self.assertEqual(definition[1], [])
+ self.assertEqual(
+ definition[2],
+ {"name": "Pony", "options": {"permissions": [("can_groom", "Can groom")]}},
+ )
+
+ def test_alter_model_options_emptying(self):
+ """
+ The AlterModelOptions operation removes keys from the dict (#23121)
+ """
+ project_state = self.set_up_test_model("test_almoop", options=True)
+ # Test the state alteration (no DB alteration to test)
+ operation = migrations.AlterModelOptions("Pony", {})
+ self.assertEqual(operation.describe(), "Change Meta options on Pony")
+ new_state = project_state.clone()
+ operation.state_forwards("test_almoop", new_state)
+ self.assertEqual(
+ len(
+ project_state.models["test_almoop", "pony"].options.get(
+ "permissions", []
+ )
+ ),
+ 1,
+ )
+ self.assertEqual(
+ len(new_state.models["test_almoop", "pony"].options.get("permissions", [])),
+ 0,
+ )
+ # And deconstruction
+ definition = operation.deconstruct()
+ self.assertEqual(definition[0], "AlterModelOptions")
+ self.assertEqual(definition[1], [])
+ self.assertEqual(definition[2], {"name": "Pony", "options": {}})
+
+ def test_alter_order_with_respect_to(self):
+ """
+ Tests the AlterOrderWithRespectTo operation.
+ """
+ project_state = self.set_up_test_model("test_alorwrtto", related_model=True)
+ # Test the state alteration
+ operation = migrations.AlterOrderWithRespectTo("Rider", "pony")
+ self.assertEqual(
+ operation.describe(), "Set order_with_respect_to on Rider to pony"
+ )
+ self.assertEqual(
+ operation.migration_name_fragment,
+ "alter_rider_order_with_respect_to",
+ )
+ new_state = project_state.clone()
+ operation.state_forwards("test_alorwrtto", new_state)
+ self.assertIsNone(
+ project_state.models["test_alorwrtto", "rider"].options.get(
+ "order_with_respect_to", None
+ )
+ )
+ self.assertEqual(
+ new_state.models["test_alorwrtto", "rider"].options.get(
+ "order_with_respect_to", None
+ ),
+ "pony",
+ )
+ # Make sure there's no matching index
+ self.assertColumnNotExists("test_alorwrtto_rider", "_order")
+ # Create some rows before alteration
+ rendered_state = project_state.apps
+ pony = rendered_state.get_model("test_alorwrtto", "Pony").objects.create(
+ weight=50
+ )
+ rider1 = rendered_state.get_model("test_alorwrtto", "Rider").objects.create(
+ pony=pony
+ )
+ rider1.friend = rider1
+ rider1.save()
+ rider2 = rendered_state.get_model("test_alorwrtto", "Rider").objects.create(
+ pony=pony
+ )
+ rider2.friend = rider2
+ rider2.save()
+ # Test the database alteration
+ with connection.schema_editor() as editor:
+ operation.database_forwards(
+ "test_alorwrtto", editor, project_state, new_state
+ )
+ self.assertColumnExists("test_alorwrtto_rider", "_order")
+ # Check for correct value in rows
+ updated_riders = new_state.apps.get_model(
+ "test_alorwrtto", "Rider"
+ ).objects.all()
+ self.assertEqual(updated_riders[0]._order, 0)
+ self.assertEqual(updated_riders[1]._order, 0)
+ # And test reversal
+ with connection.schema_editor() as editor:
+ operation.database_backwards(
+ "test_alorwrtto", editor, new_state, project_state
+ )
+ self.assertColumnNotExists("test_alorwrtto_rider", "_order")
+ # And deconstruction
+ definition = operation.deconstruct()
+ self.assertEqual(definition[0], "AlterOrderWithRespectTo")
+ self.assertEqual(definition[1], [])
+ self.assertEqual(
+ definition[2], {"name": "Rider", "order_with_respect_to": "pony"}
+ )
+
+ def test_alter_model_managers(self):
+ """
+ The managers on a model are set.
+ """
+ project_state = self.set_up_test_model("test_almoma")
+ # Test the state alteration
+ operation = migrations.AlterModelManagers(
+ "Pony",
+ managers=[
+ ("food_qs", FoodQuerySet.as_manager()),
+ ("food_mgr", FoodManager("a", "b")),
+ ("food_mgr_kwargs", FoodManager("x", "y", 3, 4)),
+ ],
+ )
+ self.assertEqual(operation.describe(), "Change managers on Pony")
+ self.assertEqual(operation.migration_name_fragment, "alter_pony_managers")
+ managers = project_state.models["test_almoma", "pony"].managers
+ self.assertEqual(managers, [])
+
+ new_state = project_state.clone()
+ operation.state_forwards("test_almoma", new_state)
+ self.assertIn(("test_almoma", "pony"), new_state.models)
+ managers = new_state.models["test_almoma", "pony"].managers
+ self.assertEqual(managers[0][0], "food_qs")
+ self.assertIsInstance(managers[0][1], models.Manager)
+ self.assertEqual(managers[1][0], "food_mgr")
+ self.assertIsInstance(managers[1][1], FoodManager)
+ self.assertEqual(managers[1][1].args, ("a", "b", 1, 2))
+ self.assertEqual(managers[2][0], "food_mgr_kwargs")
+ self.assertIsInstance(managers[2][1], FoodManager)
+ self.assertEqual(managers[2][1].args, ("x", "y", 3, 4))
+ rendered_state = new_state.apps
+ model = rendered_state.get_model("test_almoma", "pony")
+ self.assertIsInstance(model.food_qs, models.Manager)
+ self.assertIsInstance(model.food_mgr, FoodManager)
+ self.assertIsInstance(model.food_mgr_kwargs, FoodManager)
+
+ def test_alter_model_managers_emptying(self):
+ """
+ The managers on a model are set.
+ """
+ project_state = self.set_up_test_model("test_almomae", manager_model=True)
+ # Test the state alteration
+ operation = migrations.AlterModelManagers("Food", managers=[])
+ self.assertEqual(operation.describe(), "Change managers on Food")
+ self.assertIn(("test_almomae", "food"), project_state.models)
+ managers = project_state.models["test_almomae", "food"].managers
+ self.assertEqual(managers[0][0], "food_qs")
+ self.assertIsInstance(managers[0][1], models.Manager)
+ self.assertEqual(managers[1][0], "food_mgr")
+ self.assertIsInstance(managers[1][1], FoodManager)
+ self.assertEqual(managers[1][1].args, ("a", "b", 1, 2))
+ self.assertEqual(managers[2][0], "food_mgr_kwargs")
+ self.assertIsInstance(managers[2][1], FoodManager)
+ self.assertEqual(managers[2][1].args, ("x", "y", 3, 4))
+
+ new_state = project_state.clone()
+ operation.state_forwards("test_almomae", new_state)
+ managers = new_state.models["test_almomae", "food"].managers
+ self.assertEqual(managers, [])
+
+ def test_alter_fk(self):
+ """
+ Creating and then altering an FK works correctly
+ and deals with the pending SQL (#23091)
+ """
+ project_state = self.set_up_test_model("test_alfk")
+ # Test adding and then altering the FK in one go
+ create_operation = migrations.CreateModel(
+ name="Rider",
+ fields=[
+ ("id", models.AutoField(primary_key=True)),
+ ("pony", models.ForeignKey("Pony", models.CASCADE)),
+ ],
+ )
+ create_state = project_state.clone()
+ create_operation.state_forwards("test_alfk", create_state)
+ alter_operation = migrations.AlterField(
+ model_name="Rider",
+ name="pony",
+ field=models.ForeignKey("Pony", models.CASCADE, editable=False),
+ )
+ alter_state = create_state.clone()
+ alter_operation.state_forwards("test_alfk", alter_state)
+ with connection.schema_editor() as editor:
+ create_operation.database_forwards(
+ "test_alfk", editor, project_state, create_state
+ )
+ alter_operation.database_forwards(
+ "test_alfk", editor, create_state, alter_state
+ )
+
+ def test_alter_fk_non_fk(self):
+ """
+ Altering an FK to a non-FK works (#23244)
+ """
+ # Test the state alteration
+ operation = migrations.AlterField(
+ model_name="Rider",
+ name="pony",
+ field=models.FloatField(),
+ )
+ project_state, new_state = self.make_test_state(
+ "test_afknfk", operation, related_model=True
+ )
+ # Test the database alteration
+ self.assertColumnExists("test_afknfk_rider", "pony_id")
+ self.assertColumnNotExists("test_afknfk_rider", "pony")
+ with connection.schema_editor() as editor:
+ operation.database_forwards("test_afknfk", editor, project_state, new_state)
+ self.assertColumnExists("test_afknfk_rider", "pony")
+ self.assertColumnNotExists("test_afknfk_rider", "pony_id")
+ # And test reversal
+ with connection.schema_editor() as editor:
+ operation.database_backwards(
+ "test_afknfk", editor, new_state, project_state
+ )
+ self.assertColumnExists("test_afknfk_rider", "pony_id")
+ self.assertColumnNotExists("test_afknfk_rider", "pony")
+
+ def test_run_sql(self):
+ """
+ Tests the RunSQL operation.
+ """
+ project_state = self.set_up_test_model("test_runsql")
+ # Create the operation
+ operation = migrations.RunSQL(
+ # Use a multi-line string with a comment to test splitting on
+ # SQLite and MySQL respectively.
+ "CREATE TABLE i_love_ponies (id int, special_thing varchar(15));\n"
+ "INSERT INTO i_love_ponies (id, special_thing) "
+ "VALUES (1, 'i love ponies'); -- this is magic!\n"
+ "INSERT INTO i_love_ponies (id, special_thing) "
+ "VALUES (2, 'i love django');\n"
+ "UPDATE i_love_ponies SET special_thing = 'Ponies' "
+ "WHERE special_thing LIKE '%%ponies';"
+ "UPDATE i_love_ponies SET special_thing = 'Django' "
+ "WHERE special_thing LIKE '%django';",
+ # Run delete queries to test for parameter substitution failure
+ # reported in #23426
+ "DELETE FROM i_love_ponies WHERE special_thing LIKE '%Django%';"
+ "DELETE FROM i_love_ponies WHERE special_thing LIKE '%%Ponies%%';"
+ "DROP TABLE i_love_ponies",
+ state_operations=[
+ migrations.CreateModel(
+ "SomethingElse", [("id", models.AutoField(primary_key=True))]
+ )
+ ],
+ )
+ self.assertEqual(operation.describe(), "Raw SQL operation")
+ # Test the state alteration
+ new_state = project_state.clone()
+ operation.state_forwards("test_runsql", new_state)
+ self.assertEqual(
+ len(new_state.models["test_runsql", "somethingelse"].fields), 1
+ )
+ # Make sure there's no table
+ self.assertTableNotExists("i_love_ponies")
+ # Test SQL collection
+ with connection.schema_editor(collect_sql=True) as editor:
+ operation.database_forwards("test_runsql", editor, project_state, new_state)
+ self.assertIn("LIKE '%%ponies';", "\n".join(editor.collected_sql))
+ operation.database_backwards(
+ "test_runsql", editor, project_state, new_state
+ )
+ self.assertIn("LIKE '%%Ponies%%';", "\n".join(editor.collected_sql))
+ # Test the database alteration
+ with connection.schema_editor() as editor:
+ operation.database_forwards("test_runsql", editor, project_state, new_state)
+ self.assertTableExists("i_love_ponies")
+ # Make sure all the SQL was processed
+ with connection.cursor() as cursor:
+ cursor.execute("SELECT COUNT(*) FROM i_love_ponies")
+ self.assertEqual(cursor.fetchall()[0][0], 2)
+ cursor.execute(
+ "SELECT COUNT(*) FROM i_love_ponies WHERE special_thing = 'Django'"
+ )
+ self.assertEqual(cursor.fetchall()[0][0], 1)
+ cursor.execute(
+ "SELECT COUNT(*) FROM i_love_ponies WHERE special_thing = 'Ponies'"
+ )
+ self.assertEqual(cursor.fetchall()[0][0], 1)
+ # And test reversal
+ self.assertTrue(operation.reversible)
+ with connection.schema_editor() as editor:
+ operation.database_backwards(
+ "test_runsql", editor, new_state, project_state
+ )
+ self.assertTableNotExists("i_love_ponies")
+ # And deconstruction
+ definition = operation.deconstruct()
+ self.assertEqual(definition[0], "RunSQL")
+ self.assertEqual(definition[1], [])
+ self.assertEqual(
+ sorted(definition[2]), ["reverse_sql", "sql", "state_operations"]
+ )
+ # And elidable reduction
+ self.assertIs(False, operation.reduce(operation, []))
+ elidable_operation = migrations.RunSQL("SELECT 1 FROM void;", elidable=True)
+ self.assertEqual(elidable_operation.reduce(operation, []), [operation])
+
+ def test_run_sql_params(self):
+ """
+ #23426 - RunSQL should accept parameters.
+ """
+ project_state = self.set_up_test_model("test_runsql")
+ # Create the operation
+ operation = migrations.RunSQL(
+ ["CREATE TABLE i_love_ponies (id int, special_thing varchar(15));"],
+ ["DROP TABLE i_love_ponies"],
+ )
+ param_operation = migrations.RunSQL(
+ # forwards
+ (
+ "INSERT INTO i_love_ponies (id, special_thing) VALUES (1, 'Django');",
+ [
+ "INSERT INTO i_love_ponies (id, special_thing) VALUES (2, %s);",
+ ["Ponies"],
+ ],
+ (
+ "INSERT INTO i_love_ponies (id, special_thing) VALUES (%s, %s);",
+ (
+ 3,
+ "Python",
+ ),
+ ),
+ ),
+ # backwards
+ [
+ "DELETE FROM i_love_ponies WHERE special_thing = 'Django';",
+ ["DELETE FROM i_love_ponies WHERE special_thing = 'Ponies';", None],
+ (
+ "DELETE FROM i_love_ponies WHERE id = %s OR special_thing = %s;",
+ [3, "Python"],
+ ),
+ ],
+ )
+
+ # Make sure there's no table
+ self.assertTableNotExists("i_love_ponies")
+ new_state = project_state.clone()
+ # Test the database alteration
+ with connection.schema_editor() as editor:
+ operation.database_forwards("test_runsql", editor, project_state, new_state)
+
+ # Test parameter passing
+ with connection.schema_editor() as editor:
+ param_operation.database_forwards(
+ "test_runsql", editor, project_state, new_state
+ )
+ # Make sure all the SQL was processed
+ with connection.cursor() as cursor:
+ cursor.execute("SELECT COUNT(*) FROM i_love_ponies")
+ self.assertEqual(cursor.fetchall()[0][0], 3)
+
+ with connection.schema_editor() as editor:
+ param_operation.database_backwards(
+ "test_runsql", editor, new_state, project_state
+ )
+ with connection.cursor() as cursor:
+ cursor.execute("SELECT COUNT(*) FROM i_love_ponies")
+ self.assertEqual(cursor.fetchall()[0][0], 0)
+
+ # And test reversal
+ with connection.schema_editor() as editor:
+ operation.database_backwards(
+ "test_runsql", editor, new_state, project_state
+ )
+ self.assertTableNotExists("i_love_ponies")
+
+ def test_run_sql_params_invalid(self):
+ """
+ #23426 - RunSQL should fail when a list of statements with an incorrect
+ number of tuples is given.
+ """
+ project_state = self.set_up_test_model("test_runsql")
+ new_state = project_state.clone()
+ operation = migrations.RunSQL(
+ # forwards
+ [["INSERT INTO foo (bar) VALUES ('buz');"]],
+ # backwards
+ (("DELETE FROM foo WHERE bar = 'buz';", "invalid", "parameter count"),),
+ )
+
+ with connection.schema_editor() as editor:
+ with self.assertRaisesMessage(ValueError, "Expected a 2-tuple but got 1"):
+ operation.database_forwards(
+ "test_runsql", editor, project_state, new_state
+ )
+
+ with connection.schema_editor() as editor:
+ with self.assertRaisesMessage(ValueError, "Expected a 2-tuple but got 3"):
+ operation.database_backwards(
+ "test_runsql", editor, new_state, project_state
+ )
+
+ def test_run_sql_noop(self):
+ """
+ #24098 - Tests no-op RunSQL operations.
+ """
+ operation = migrations.RunSQL(migrations.RunSQL.noop, migrations.RunSQL.noop)
+ with connection.schema_editor() as editor:
+ operation.database_forwards("test_runsql", editor, None, None)
+ operation.database_backwards("test_runsql", editor, None, None)
+
+ def test_run_sql_add_missing_semicolon_on_collect_sql(self):
+ project_state = self.set_up_test_model("test_runsql")
+ new_state = project_state.clone()
+ tests = [
+ "INSERT INTO test_runsql_pony (pink, weight) VALUES (1, 1);\n",
+ "INSERT INTO test_runsql_pony (pink, weight) VALUES (1, 1)\n",
+ ]
+ for sql in tests:
+ with self.subTest(sql=sql):
+ operation = migrations.RunSQL(sql, migrations.RunPython.noop)
+ with connection.schema_editor(collect_sql=True) as editor:
+ operation.database_forwards(
+ "test_runsql", editor, project_state, new_state
+ )
+ collected_sql = "\n".join(editor.collected_sql)
+ self.assertEqual(collected_sql.count(";"), 1)
+
+ def test_run_python(self):
+ """
+ Tests the RunPython operation
+ """
+
+ project_state = self.set_up_test_model("test_runpython", mti_model=True)
+
+ # Create the operation
+ def inner_method(models, schema_editor):
+ Pony = models.get_model("test_runpython", "Pony")
+ Pony.objects.create(pink=1, weight=3.55)
+ Pony.objects.create(weight=5)
+
+ def inner_method_reverse(models, schema_editor):
+ Pony = models.get_model("test_runpython", "Pony")
+ Pony.objects.filter(pink=1, weight=3.55).delete()
+ Pony.objects.filter(weight=5).delete()
+
+ operation = migrations.RunPython(
+ inner_method, reverse_code=inner_method_reverse
+ )
+ self.assertEqual(operation.describe(), "Raw Python operation")
+ # Test the state alteration does nothing
+ new_state = project_state.clone()
+ operation.state_forwards("test_runpython", new_state)
+ self.assertEqual(new_state, project_state)
+ # Test the database alteration
+ self.assertEqual(
+ project_state.apps.get_model("test_runpython", "Pony").objects.count(), 0
+ )
+ with connection.schema_editor() as editor:
+ operation.database_forwards(
+ "test_runpython", editor, project_state, new_state
+ )
+ self.assertEqual(
+ project_state.apps.get_model("test_runpython", "Pony").objects.count(), 2
+ )
+ # Now test reversal
+ self.assertTrue(operation.reversible)
+ with connection.schema_editor() as editor:
+ operation.database_backwards(
+ "test_runpython", editor, project_state, new_state
+ )
+ self.assertEqual(
+ project_state.apps.get_model("test_runpython", "Pony").objects.count(), 0
+ )
+ # Now test we can't use a string
+ with self.assertRaisesMessage(
+ ValueError, "RunPython must be supplied with a callable"
+ ):
+ migrations.RunPython("print 'ahahaha'")
+ # And deconstruction
+ definition = operation.deconstruct()
+ self.assertEqual(definition[0], "RunPython")
+ self.assertEqual(definition[1], [])
+ self.assertEqual(sorted(definition[2]), ["code", "reverse_code"])
+
+ # Also test reversal fails, with an operation identical to above but
+ # without reverse_code set.
+ no_reverse_operation = migrations.RunPython(inner_method)
+ self.assertFalse(no_reverse_operation.reversible)
+ with connection.schema_editor() as editor:
+ no_reverse_operation.database_forwards(
+ "test_runpython", editor, project_state, new_state
+ )
+ with self.assertRaises(NotImplementedError):
+ no_reverse_operation.database_backwards(
+ "test_runpython", editor, new_state, project_state
+ )
+ self.assertEqual(
+ project_state.apps.get_model("test_runpython", "Pony").objects.count(), 2
+ )
+
+ def create_ponies(models, schema_editor):
+ Pony = models.get_model("test_runpython", "Pony")
+ pony1 = Pony.objects.create(pink=1, weight=3.55)
+ self.assertIsNot(pony1.pk, None)
+ pony2 = Pony.objects.create(weight=5)
+ self.assertIsNot(pony2.pk, None)
+ self.assertNotEqual(pony1.pk, pony2.pk)
+
+ operation = migrations.RunPython(create_ponies)
+ with connection.schema_editor() as editor:
+ operation.database_forwards(
+ "test_runpython", editor, project_state, new_state
+ )
+ self.assertEqual(
+ project_state.apps.get_model("test_runpython", "Pony").objects.count(), 4
+ )
+ # And deconstruction
+ definition = operation.deconstruct()
+ self.assertEqual(definition[0], "RunPython")
+ self.assertEqual(definition[1], [])
+ self.assertEqual(sorted(definition[2]), ["code"])
+
+ def create_shetlandponies(models, schema_editor):
+ ShetlandPony = models.get_model("test_runpython", "ShetlandPony")
+ pony1 = ShetlandPony.objects.create(weight=4.0)
+ self.assertIsNot(pony1.pk, None)
+ pony2 = ShetlandPony.objects.create(weight=5.0)
+ self.assertIsNot(pony2.pk, None)
+ self.assertNotEqual(pony1.pk, pony2.pk)
+
+ operation = migrations.RunPython(create_shetlandponies)
+ with connection.schema_editor() as editor:
+ operation.database_forwards(
+ "test_runpython", editor, project_state, new_state
+ )
+ self.assertEqual(
+ project_state.apps.get_model("test_runpython", "Pony").objects.count(), 6
+ )
+ self.assertEqual(
+ project_state.apps.get_model(
+ "test_runpython", "ShetlandPony"
+ ).objects.count(),
+ 2,
+ )
+ # And elidable reduction
+ self.assertIs(False, operation.reduce(operation, []))
+ elidable_operation = migrations.RunPython(inner_method, elidable=True)
+ self.assertEqual(elidable_operation.reduce(operation, []), [operation])
+
+ def test_run_python_atomic(self):
+ """
+ Tests the RunPython operation correctly handles the "atomic" keyword
+ """
+ project_state = self.set_up_test_model("test_runpythonatomic", mti_model=True)
+
+ def inner_method(models, schema_editor):
+ Pony = models.get_model("test_runpythonatomic", "Pony")
+ Pony.objects.create(pink=1, weight=3.55)
+ raise ValueError("Adrian hates ponies.")
+
+ # Verify atomicity when applying.
+ atomic_migration = Migration("test", "test_runpythonatomic")
+ atomic_migration.operations = [
+ migrations.RunPython(inner_method, reverse_code=inner_method)
+ ]
+ non_atomic_migration = Migration("test", "test_runpythonatomic")
+ non_atomic_migration.operations = [
+ migrations.RunPython(inner_method, reverse_code=inner_method, atomic=False)
+ ]
+ # If we're a fully-transactional database, both versions should rollback
+ if connection.features.can_rollback_ddl:
+ self.assertEqual(
+ project_state.apps.get_model(
+ "test_runpythonatomic", "Pony"
+ ).objects.count(),
+ 0,
+ )
+ with self.assertRaises(ValueError):
+ with connection.schema_editor() as editor:
+ atomic_migration.apply(project_state, editor)
+ self.assertEqual(
+ project_state.apps.get_model(
+ "test_runpythonatomic", "Pony"
+ ).objects.count(),
+ 0,
+ )
+ with self.assertRaises(ValueError):
+ with connection.schema_editor() as editor:
+ non_atomic_migration.apply(project_state, editor)
+ self.assertEqual(
+ project_state.apps.get_model(
+ "test_runpythonatomic", "Pony"
+ ).objects.count(),
+ 0,
+ )
+ # Otherwise, the non-atomic operation should leave a row there
+ else:
+ self.assertEqual(
+ project_state.apps.get_model(
+ "test_runpythonatomic", "Pony"
+ ).objects.count(),
+ 0,
+ )
+ with self.assertRaises(ValueError):
+ with connection.schema_editor() as editor:
+ atomic_migration.apply(project_state, editor)
+ self.assertEqual(
+ project_state.apps.get_model(
+ "test_runpythonatomic", "Pony"
+ ).objects.count(),
+ 0,
+ )
+ with self.assertRaises(ValueError):
+ with connection.schema_editor() as editor:
+ non_atomic_migration.apply(project_state, editor)
+ self.assertEqual(
+ project_state.apps.get_model(
+ "test_runpythonatomic", "Pony"
+ ).objects.count(),
+ 1,
+ )
+ # Reset object count to zero and verify atomicity when unapplying.
+ project_state.apps.get_model(
+ "test_runpythonatomic", "Pony"
+ ).objects.all().delete()
+ # On a fully-transactional database, both versions rollback.
+ if connection.features.can_rollback_ddl:
+ self.assertEqual(
+ project_state.apps.get_model(
+ "test_runpythonatomic", "Pony"
+ ).objects.count(),
+ 0,
+ )
+ with self.assertRaises(ValueError):
+ with connection.schema_editor() as editor:
+ atomic_migration.unapply(project_state, editor)
+ self.assertEqual(
+ project_state.apps.get_model(
+ "test_runpythonatomic", "Pony"
+ ).objects.count(),
+ 0,
+ )
+ with self.assertRaises(ValueError):
+ with connection.schema_editor() as editor:
+ non_atomic_migration.unapply(project_state, editor)
+ self.assertEqual(
+ project_state.apps.get_model(
+ "test_runpythonatomic", "Pony"
+ ).objects.count(),
+ 0,
+ )
+ # Otherwise, the non-atomic operation leaves a row there.
+ else:
+ self.assertEqual(
+ project_state.apps.get_model(
+ "test_runpythonatomic", "Pony"
+ ).objects.count(),
+ 0,
+ )
+ with self.assertRaises(ValueError):
+ with connection.schema_editor() as editor:
+ atomic_migration.unapply(project_state, editor)
+ self.assertEqual(
+ project_state.apps.get_model(
+ "test_runpythonatomic", "Pony"
+ ).objects.count(),
+ 0,
+ )
+ with self.assertRaises(ValueError):
+ with connection.schema_editor() as editor:
+ non_atomic_migration.unapply(project_state, editor)
+ self.assertEqual(
+ project_state.apps.get_model(
+ "test_runpythonatomic", "Pony"
+ ).objects.count(),
+ 1,
+ )
+ # Verify deconstruction.
+ definition = non_atomic_migration.operations[0].deconstruct()
+ self.assertEqual(definition[0], "RunPython")
+ self.assertEqual(definition[1], [])
+ self.assertEqual(sorted(definition[2]), ["atomic", "code", "reverse_code"])
+
+ def test_run_python_related_assignment(self):
+ """
+ #24282 - Model changes to a FK reverse side update the model
+ on the FK side as well.
+ """
+
+ def inner_method(models, schema_editor):
+ Author = models.get_model("test_authors", "Author")
+ Book = models.get_model("test_books", "Book")
+ author = Author.objects.create(name="Hemingway")
+ Book.objects.create(title="Old Man and The Sea", author=author)
+
+ create_author = migrations.CreateModel(
+ "Author",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ("name", models.CharField(max_length=100)),
+ ],
+ options={},
+ )
+ create_book = migrations.CreateModel(
+ "Book",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ("title", models.CharField(max_length=100)),
+ ("author", models.ForeignKey("test_authors.Author", models.CASCADE)),
+ ],
+ options={},
+ )
+ add_hometown = migrations.AddField(
+ "Author",
+ "hometown",
+ models.CharField(max_length=100),
+ )
+ create_old_man = migrations.RunPython(inner_method, inner_method)
+
+ project_state = ProjectState()
+ new_state = project_state.clone()
+ with connection.schema_editor() as editor:
+ create_author.state_forwards("test_authors", new_state)
+ create_author.database_forwards(
+ "test_authors", editor, project_state, new_state
+ )
+ project_state = new_state
+ new_state = new_state.clone()
+ with connection.schema_editor() as editor:
+ create_book.state_forwards("test_books", new_state)
+ create_book.database_forwards(
+ "test_books", editor, project_state, new_state
+ )
+ project_state = new_state
+ new_state = new_state.clone()
+ with connection.schema_editor() as editor:
+ add_hometown.state_forwards("test_authors", new_state)
+ add_hometown.database_forwards(
+ "test_authors", editor, project_state, new_state
+ )
+ project_state = new_state
+ new_state = new_state.clone()
+ with connection.schema_editor() as editor:
+ create_old_man.state_forwards("test_books", new_state)
+ create_old_man.database_forwards(
+ "test_books", editor, project_state, new_state
+ )
+
+ def test_model_with_bigautofield(self):
+ """
+ A model with BigAutoField can be created.
+ """
+
+ def create_data(models, schema_editor):
+ Author = models.get_model("test_author", "Author")
+ Book = models.get_model("test_book", "Book")
+ author1 = Author.objects.create(name="Hemingway")
+ Book.objects.create(title="Old Man and The Sea", author=author1)
+ Book.objects.create(id=2**33, title="A farewell to arms", author=author1)
+
+ author2 = Author.objects.create(id=2**33, name="Remarque")
+ Book.objects.create(title="All quiet on the western front", author=author2)
+ Book.objects.create(title="Arc de Triomphe", author=author2)
+
+ create_author = migrations.CreateModel(
+ "Author",
+ [
+ ("id", models.BigAutoField(primary_key=True)),
+ ("name", models.CharField(max_length=100)),
+ ],
+ options={},
+ )
+ create_book = migrations.CreateModel(
+ "Book",
+ [
+ ("id", models.BigAutoField(primary_key=True)),
+ ("title", models.CharField(max_length=100)),
+ (
+ "author",
+ models.ForeignKey(
+ to="test_author.Author", on_delete=models.CASCADE
+ ),
+ ),
+ ],
+ options={},
+ )
+ fill_data = migrations.RunPython(create_data)
+
+ project_state = ProjectState()
+ new_state = project_state.clone()
+ with connection.schema_editor() as editor:
+ create_author.state_forwards("test_author", new_state)
+ create_author.database_forwards(
+ "test_author", editor, project_state, new_state
+ )
+
+ project_state = new_state
+ new_state = new_state.clone()
+ with connection.schema_editor() as editor:
+ create_book.state_forwards("test_book", new_state)
+ create_book.database_forwards("test_book", editor, project_state, new_state)
+
+ project_state = new_state
+ new_state = new_state.clone()
+ with connection.schema_editor() as editor:
+ fill_data.state_forwards("fill_data", new_state)
+ fill_data.database_forwards("fill_data", editor, project_state, new_state)
+
+ def _test_autofield_foreignfield_growth(
+ self, source_field, target_field, target_value
+ ):
+ """
+ A field may be migrated in the following ways:
+
+ - AutoField to BigAutoField
+ - SmallAutoField to AutoField
+ - SmallAutoField to BigAutoField
+ """
+
+ def create_initial_data(models, schema_editor):
+ Article = models.get_model("test_article", "Article")
+ Blog = models.get_model("test_blog", "Blog")
+ blog = Blog.objects.create(name="web development done right")
+ Article.objects.create(name="Frameworks", blog=blog)
+ Article.objects.create(name="Programming Languages", blog=blog)
+
+ def create_big_data(models, schema_editor):
+ Article = models.get_model("test_article", "Article")
+ Blog = models.get_model("test_blog", "Blog")
+ blog2 = Blog.objects.create(name="Frameworks", id=target_value)
+ Article.objects.create(name="Django", blog=blog2)
+ Article.objects.create(id=target_value, name="Django2", blog=blog2)
+
+ create_blog = migrations.CreateModel(
+ "Blog",
+ [
+ ("id", source_field(primary_key=True)),
+ ("name", models.CharField(max_length=100)),
+ ],
+ options={},
+ )
+ create_article = migrations.CreateModel(
+ "Article",
+ [
+ ("id", source_field(primary_key=True)),
+ (
+ "blog",
+ models.ForeignKey(to="test_blog.Blog", on_delete=models.CASCADE),
+ ),
+ ("name", models.CharField(max_length=100)),
+ ("data", models.TextField(default="")),
+ ],
+ options={},
+ )
+ fill_initial_data = migrations.RunPython(
+ create_initial_data, create_initial_data
+ )
+ fill_big_data = migrations.RunPython(create_big_data, create_big_data)
+
+ grow_article_id = migrations.AlterField(
+ "Article", "id", target_field(primary_key=True)
+ )
+ grow_blog_id = migrations.AlterField(
+ "Blog", "id", target_field(primary_key=True)
+ )
+
+ project_state = ProjectState()
+ new_state = project_state.clone()
+ with connection.schema_editor() as editor:
+ create_blog.state_forwards("test_blog", new_state)
+ create_blog.database_forwards("test_blog", editor, project_state, new_state)
+
+ project_state = new_state
+ new_state = new_state.clone()
+ with connection.schema_editor() as editor:
+ create_article.state_forwards("test_article", new_state)
+ create_article.database_forwards(
+ "test_article", editor, project_state, new_state
+ )
+
+ project_state = new_state
+ new_state = new_state.clone()
+ with connection.schema_editor() as editor:
+ fill_initial_data.state_forwards("fill_initial_data", new_state)
+ fill_initial_data.database_forwards(
+ "fill_initial_data", editor, project_state, new_state
+ )
+
+ project_state = new_state
+ new_state = new_state.clone()
+ with connection.schema_editor() as editor:
+ grow_article_id.state_forwards("test_article", new_state)
+ grow_article_id.database_forwards(
+ "test_article", editor, project_state, new_state
+ )
+
+ state = new_state.clone()
+ article = state.apps.get_model("test_article.Article")
+ self.assertIsInstance(article._meta.pk, target_field)
+
+ project_state = new_state
+ new_state = new_state.clone()
+ with connection.schema_editor() as editor:
+ grow_blog_id.state_forwards("test_blog", new_state)
+ grow_blog_id.database_forwards(
+ "test_blog", editor, project_state, new_state
+ )
+
+ state = new_state.clone()
+ blog = state.apps.get_model("test_blog.Blog")
+ self.assertIsInstance(blog._meta.pk, target_field)
+
+ project_state = new_state
+ new_state = new_state.clone()
+ with connection.schema_editor() as editor:
+ fill_big_data.state_forwards("fill_big_data", new_state)
+ fill_big_data.database_forwards(
+ "fill_big_data", editor, project_state, new_state
+ )
+
+ def test_autofield__bigautofield_foreignfield_growth(self):
+ """A field may be migrated from AutoField to BigAutoField."""
+ self._test_autofield_foreignfield_growth(
+ models.AutoField,
+ models.BigAutoField,
+ 2**33,
+ )
+
+ def test_smallfield_autofield_foreignfield_growth(self):
+ """A field may be migrated from SmallAutoField to AutoField."""
+ self._test_autofield_foreignfield_growth(
+ models.SmallAutoField,
+ models.AutoField,
+ 2**22,
+ )
+
+ def test_smallfield_bigautofield_foreignfield_growth(self):
+ """A field may be migrated from SmallAutoField to BigAutoField."""
+ self._test_autofield_foreignfield_growth(
+ models.SmallAutoField,
+ models.BigAutoField,
+ 2**33,
+ )
+
+ def test_run_python_noop(self):
+ """
+ #24098 - Tests no-op RunPython operations.
+ """
+ project_state = ProjectState()
+ new_state = project_state.clone()
+ operation = migrations.RunPython(
+ migrations.RunPython.noop, migrations.RunPython.noop
+ )
+ with connection.schema_editor() as editor:
+ operation.database_forwards(
+ "test_runpython", editor, project_state, new_state
+ )
+ operation.database_backwards(
+ "test_runpython", editor, new_state, project_state
+ )
+
+ def test_separate_database_and_state(self):
+ """
+ Tests the SeparateDatabaseAndState operation.
+ """
+ project_state = self.set_up_test_model("test_separatedatabaseandstate")
+ # Create the operation
+ database_operation = migrations.RunSQL(
+ "CREATE TABLE i_love_ponies (id int, special_thing int);",
+ "DROP TABLE i_love_ponies;",
+ )
+ state_operation = migrations.CreateModel(
+ "SomethingElse", [("id", models.AutoField(primary_key=True))]
+ )
+ operation = migrations.SeparateDatabaseAndState(
+ state_operations=[state_operation], database_operations=[database_operation]
+ )
+ self.assertEqual(
+ operation.describe(), "Custom state/database change combination"
+ )
+ # Test the state alteration
+ new_state = project_state.clone()
+ operation.state_forwards("test_separatedatabaseandstate", new_state)
+ self.assertEqual(
+ len(
+ new_state.models[
+ "test_separatedatabaseandstate", "somethingelse"
+ ].fields
+ ),
+ 1,
+ )
+ # Make sure there's no table
+ self.assertTableNotExists("i_love_ponies")
+ # Test the database alteration
+ with connection.schema_editor() as editor:
+ operation.database_forwards(
+ "test_separatedatabaseandstate", editor, project_state, new_state
+ )
+ self.assertTableExists("i_love_ponies")
+ # And test reversal
+ self.assertTrue(operation.reversible)
+ with connection.schema_editor() as editor:
+ operation.database_backwards(
+ "test_separatedatabaseandstate", editor, new_state, project_state
+ )
+ self.assertTableNotExists("i_love_ponies")
+ # And deconstruction
+ definition = operation.deconstruct()
+ self.assertEqual(definition[0], "SeparateDatabaseAndState")
+ self.assertEqual(definition[1], [])
+ self.assertEqual(
+ sorted(definition[2]), ["database_operations", "state_operations"]
+ )
+
+ def test_separate_database_and_state2(self):
+ """
+ A complex SeparateDatabaseAndState operation: Multiple operations both
+ for state and database. Verify the state dependencies within each list
+ and that state ops don't affect the database.
+ """
+ app_label = "test_separatedatabaseandstate2"
+ project_state = self.set_up_test_model(app_label)
+ # Create the operation
+ database_operations = [
+ migrations.CreateModel(
+ "ILovePonies",
+ [("id", models.AutoField(primary_key=True))],
+ options={"db_table": "iloveponies"},
+ ),
+ migrations.CreateModel(
+ "ILoveMorePonies",
+ # We use IntegerField and not AutoField because
+ # the model is going to be deleted immediately
+ # and with an AutoField this fails on Oracle
+ [("id", models.IntegerField(primary_key=True))],
+ options={"db_table": "ilovemoreponies"},
+ ),
+ migrations.DeleteModel("ILoveMorePonies"),
+ migrations.CreateModel(
+ "ILoveEvenMorePonies",
+ [("id", models.AutoField(primary_key=True))],
+ options={"db_table": "iloveevenmoreponies"},
+ ),
+ ]
+ state_operations = [
+ migrations.CreateModel(
+ "SomethingElse",
+ [("id", models.AutoField(primary_key=True))],
+ options={"db_table": "somethingelse"},
+ ),
+ migrations.DeleteModel("SomethingElse"),
+ migrations.CreateModel(
+ "SomethingCompletelyDifferent",
+ [("id", models.AutoField(primary_key=True))],
+ options={"db_table": "somethingcompletelydifferent"},
+ ),
+ ]
+ operation = migrations.SeparateDatabaseAndState(
+ state_operations=state_operations,
+ database_operations=database_operations,
+ )
+ # Test the state alteration
+ new_state = project_state.clone()
+ operation.state_forwards(app_label, new_state)
+
+ def assertModelsAndTables(after_db):
+ # Tables and models exist, or don't, as they should:
+ self.assertNotIn((app_label, "somethingelse"), new_state.models)
+ self.assertEqual(
+ len(new_state.models[app_label, "somethingcompletelydifferent"].fields),
+ 1,
+ )
+ self.assertNotIn((app_label, "iloveponiesonies"), new_state.models)
+ self.assertNotIn((app_label, "ilovemoreponies"), new_state.models)
+ self.assertNotIn((app_label, "iloveevenmoreponies"), new_state.models)
+ self.assertTableNotExists("somethingelse")
+ self.assertTableNotExists("somethingcompletelydifferent")
+ self.assertTableNotExists("ilovemoreponies")
+ if after_db:
+ self.assertTableExists("iloveponies")
+ self.assertTableExists("iloveevenmoreponies")
+ else:
+ self.assertTableNotExists("iloveponies")
+ self.assertTableNotExists("iloveevenmoreponies")
+
+ assertModelsAndTables(after_db=False)
+ # Test the database alteration
+ with connection.schema_editor() as editor:
+ operation.database_forwards(app_label, editor, project_state, new_state)
+ assertModelsAndTables(after_db=True)
+ # And test reversal
+ self.assertTrue(operation.reversible)
+ with connection.schema_editor() as editor:
+ operation.database_backwards(app_label, editor, new_state, project_state)
+ assertModelsAndTables(after_db=False)
+
+
+class SwappableOperationTests(OperationTestBase):
+ """
+ Key operations ignore swappable models
+ (we don't want to replicate all of them here, as the functionality
+ is in a common base class anyway)
+ """
+
+ available_apps = ["migrations"]
+
+ @override_settings(TEST_SWAP_MODEL="migrations.SomeFakeModel")
+ def test_create_ignore_swapped(self):
+ """
+ The CreateTable operation ignores swapped models.
+ """
+ operation = migrations.CreateModel(
+ "Pony",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ("pink", models.IntegerField(default=1)),
+ ],
+ options={
+ "swappable": "TEST_SWAP_MODEL",
+ },
+ )
+ # Test the state alteration (it should still be there!)
+ project_state = ProjectState()
+ new_state = project_state.clone()
+ operation.state_forwards("test_crigsw", new_state)
+ self.assertEqual(new_state.models["test_crigsw", "pony"].name, "Pony")
+ self.assertEqual(len(new_state.models["test_crigsw", "pony"].fields), 2)
+ # Test the database alteration
+ self.assertTableNotExists("test_crigsw_pony")
+ with connection.schema_editor() as editor:
+ operation.database_forwards("test_crigsw", editor, project_state, new_state)
+ self.assertTableNotExists("test_crigsw_pony")
+ # And test reversal
+ with connection.schema_editor() as editor:
+ operation.database_backwards(
+ "test_crigsw", editor, new_state, project_state
+ )
+ self.assertTableNotExists("test_crigsw_pony")
+
+ @override_settings(TEST_SWAP_MODEL="migrations.SomeFakeModel")
+ def test_delete_ignore_swapped(self):
+ """
+ Tests the DeleteModel operation ignores swapped models.
+ """
+ operation = migrations.DeleteModel("Pony")
+ project_state, new_state = self.make_test_state("test_dligsw", operation)
+ # Test the database alteration
+ self.assertTableNotExists("test_dligsw_pony")
+ with connection.schema_editor() as editor:
+ operation.database_forwards("test_dligsw", editor, project_state, new_state)
+ self.assertTableNotExists("test_dligsw_pony")
+ # And test reversal
+ with connection.schema_editor() as editor:
+ operation.database_backwards(
+ "test_dligsw", editor, new_state, project_state
+ )
+ self.assertTableNotExists("test_dligsw_pony")
+
+ @override_settings(TEST_SWAP_MODEL="migrations.SomeFakeModel")
+ def test_add_field_ignore_swapped(self):
+ """
+ Tests the AddField operation.
+ """
+ # Test the state alteration
+ operation = migrations.AddField(
+ "Pony",
+ "height",
+ models.FloatField(null=True, default=5),
+ )
+ project_state, new_state = self.make_test_state("test_adfligsw", operation)
+ # Test the database alteration
+ self.assertTableNotExists("test_adfligsw_pony")
+ with connection.schema_editor() as editor:
+ operation.database_forwards(
+ "test_adfligsw", editor, project_state, new_state
+ )
+ self.assertTableNotExists("test_adfligsw_pony")
+ # And test reversal
+ with connection.schema_editor() as editor:
+ operation.database_backwards(
+ "test_adfligsw", editor, new_state, project_state
+ )
+ self.assertTableNotExists("test_adfligsw_pony")
+
+ @override_settings(TEST_SWAP_MODEL="migrations.SomeFakeModel")
+ def test_indexes_ignore_swapped(self):
+ """
+ Add/RemoveIndex operations ignore swapped models.
+ """
+ operation = migrations.AddIndex(
+ "Pony", models.Index(fields=["pink"], name="my_name_idx")
+ )
+ project_state, new_state = self.make_test_state("test_adinigsw", operation)
+ with connection.schema_editor() as editor:
+ # No database queries should be run for swapped models
+ operation.database_forwards(
+ "test_adinigsw", editor, project_state, new_state
+ )
+ operation.database_backwards(
+ "test_adinigsw", editor, new_state, project_state
+ )
+
+ operation = migrations.RemoveIndex(
+ "Pony", models.Index(fields=["pink"], name="my_name_idx")
+ )
+ project_state, new_state = self.make_test_state("test_rminigsw", operation)
+ with connection.schema_editor() as editor:
+ operation.database_forwards(
+ "test_rminigsw", editor, project_state, new_state
+ )
+ operation.database_backwards(
+ "test_rminigsw", editor, new_state, project_state
+ )
+
+
+class TestCreateModel(SimpleTestCase):
+ def test_references_model_mixin(self):
+ migrations.CreateModel(
+ "name",
+ fields=[],
+ bases=(Mixin, models.Model),
+ ).references_model("other_model", "migrations")
+
+
+class FieldOperationTests(SimpleTestCase):
+ def test_references_model(self):
+ operation = FieldOperation(
+ "MoDel", "field", models.ForeignKey("Other", models.CASCADE)
+ )
+ # Model name match.
+ self.assertIs(operation.references_model("mOdEl", "migrations"), True)
+ # Referenced field.
+ self.assertIs(operation.references_model("oTher", "migrations"), True)
+ # Doesn't reference.
+ self.assertIs(operation.references_model("Whatever", "migrations"), False)
+
+ def test_references_field_by_name(self):
+ operation = FieldOperation("MoDel", "field", models.BooleanField(default=False))
+ self.assertIs(operation.references_field("model", "field", "migrations"), True)
+
+ def test_references_field_by_remote_field_model(self):
+ operation = FieldOperation(
+ "Model", "field", models.ForeignKey("Other", models.CASCADE)
+ )
+ self.assertIs(
+ operation.references_field("Other", "whatever", "migrations"), True
+ )
+ self.assertIs(
+ operation.references_field("Missing", "whatever", "migrations"), False
+ )
+
+ def test_references_field_by_from_fields(self):
+ operation = FieldOperation(
+ "Model",
+ "field",
+ models.fields.related.ForeignObject(
+ "Other", models.CASCADE, ["from"], ["to"]
+ ),
+ )
+ self.assertIs(operation.references_field("Model", "from", "migrations"), True)
+ self.assertIs(operation.references_field("Model", "to", "migrations"), False)
+ self.assertIs(operation.references_field("Other", "from", "migrations"), False)
+ self.assertIs(operation.references_field("Model", "to", "migrations"), False)
+
+ def test_references_field_by_to_fields(self):
+ operation = FieldOperation(
+ "Model",
+ "field",
+ models.ForeignKey("Other", models.CASCADE, to_field="field"),
+ )
+ self.assertIs(operation.references_field("Other", "field", "migrations"), True)
+ self.assertIs(
+ operation.references_field("Other", "whatever", "migrations"), False
+ )
+ self.assertIs(
+ operation.references_field("Missing", "whatever", "migrations"), False
+ )
+
+ def test_references_field_by_through(self):
+ operation = FieldOperation(
+ "Model", "field", models.ManyToManyField("Other", through="Through")
+ )
+ self.assertIs(
+ operation.references_field("Other", "whatever", "migrations"), True
+ )
+ self.assertIs(
+ operation.references_field("Through", "whatever", "migrations"), True
+ )
+ self.assertIs(
+ operation.references_field("Missing", "whatever", "migrations"), False
+ )
+
+ def test_reference_field_by_through_fields(self):
+ operation = FieldOperation(
+ "Model",
+ "field",
+ models.ManyToManyField(
+ "Other", through="Through", through_fields=("first", "second")
+ ),
+ )
+ self.assertIs(
+ operation.references_field("Other", "whatever", "migrations"), True
+ )
+ self.assertIs(
+ operation.references_field("Through", "whatever", "migrations"), False
+ )
+ self.assertIs(
+ operation.references_field("Through", "first", "migrations"), True
+ )
+ self.assertIs(
+ operation.references_field("Through", "second", "migrations"), True
+ )
diff --git a/testbed/django__django/tests/migrations/test_optimizer.py b/testbed/django__django/tests/migrations/test_optimizer.py
new file mode 100644
index 0000000000000000000000000000000000000000..ec5f6b4ce98bf76a2091c6b2a394938e5d0eba9c
--- /dev/null
+++ b/testbed/django__django/tests/migrations/test_optimizer.py
@@ -0,0 +1,1403 @@
+from django.db import migrations, models
+from django.db.migrations import operations
+from django.db.migrations.optimizer import MigrationOptimizer
+from django.db.migrations.serializer import serializer_factory
+from django.db.models.functions import Abs
+from django.test import SimpleTestCase
+
+from .models import EmptyManager, UnicodeModel
+
+
+class OptimizerTests(SimpleTestCase):
+ """
+ Tests the migration autodetector.
+ """
+
+ def optimize(self, operations, app_label):
+ """
+ Handy shortcut for getting results + number of loops
+ """
+ optimizer = MigrationOptimizer()
+ return optimizer.optimize(operations, app_label), optimizer._iterations
+
+ def serialize(self, value):
+ return serializer_factory(value).serialize()[0]
+
+ def assertOptimizesTo(
+ self, operations, expected, exact=None, less_than=None, app_label=None
+ ):
+ result, iterations = self.optimize(operations, app_label or "migrations")
+ result = [self.serialize(f) for f in result]
+ expected = [self.serialize(f) for f in expected]
+ self.assertEqual(expected, result)
+ if exact is not None and iterations != exact:
+ raise self.failureException(
+ "Optimization did not take exactly %s iterations (it took %s)"
+ % (exact, iterations)
+ )
+ if less_than is not None and iterations >= less_than:
+ raise self.failureException(
+ "Optimization did not take less than %s iterations (it took %s)"
+ % (less_than, iterations)
+ )
+
+ def assertDoesNotOptimize(self, operations, **kwargs):
+ self.assertOptimizesTo(operations, operations, **kwargs)
+
+ def test_none_app_label(self):
+ optimizer = MigrationOptimizer()
+ with self.assertRaisesMessage(TypeError, "app_label must be a str"):
+ optimizer.optimize([], None)
+
+ def test_single(self):
+ """
+ The optimizer does nothing on a single operation,
+ and that it does it in just one pass.
+ """
+ self.assertOptimizesTo(
+ [migrations.DeleteModel("Foo")],
+ [migrations.DeleteModel("Foo")],
+ exact=1,
+ )
+
+ def test_create_delete_model(self):
+ """
+ CreateModel and DeleteModel should collapse into nothing.
+ """
+ self.assertOptimizesTo(
+ [
+ migrations.CreateModel(
+ "Foo", [("name", models.CharField(max_length=255))]
+ ),
+ migrations.DeleteModel("Foo"),
+ ],
+ [],
+ )
+
+ def test_create_rename_model(self):
+ """
+ CreateModel should absorb RenameModels.
+ """
+ managers = [("objects", EmptyManager())]
+ self.assertOptimizesTo(
+ [
+ migrations.CreateModel(
+ name="Foo",
+ fields=[("name", models.CharField(max_length=255))],
+ options={"verbose_name": "Foo"},
+ bases=(UnicodeModel,),
+ managers=managers,
+ ),
+ migrations.RenameModel("Foo", "Bar"),
+ ],
+ [
+ migrations.CreateModel(
+ "Bar",
+ [("name", models.CharField(max_length=255))],
+ options={"verbose_name": "Foo"},
+ bases=(UnicodeModel,),
+ managers=managers,
+ )
+ ],
+ )
+
+ def test_rename_model_self(self):
+ """
+ RenameModels should absorb themselves.
+ """
+ self.assertOptimizesTo(
+ [
+ migrations.RenameModel("Foo", "Baa"),
+ migrations.RenameModel("Baa", "Bar"),
+ ],
+ [
+ migrations.RenameModel("Foo", "Bar"),
+ ],
+ )
+
+ def test_create_alter_model_options(self):
+ self.assertOptimizesTo(
+ [
+ migrations.CreateModel("Foo", fields=[]),
+ migrations.AlterModelOptions(
+ name="Foo", options={"verbose_name_plural": "Foozes"}
+ ),
+ ],
+ [
+ migrations.CreateModel(
+ "Foo", fields=[], options={"verbose_name_plural": "Foozes"}
+ ),
+ ],
+ )
+
+ def test_create_alter_model_managers(self):
+ self.assertOptimizesTo(
+ [
+ migrations.CreateModel("Foo", fields=[]),
+ migrations.AlterModelManagers(
+ name="Foo",
+ managers=[
+ ("objects", models.Manager()),
+ ("things", models.Manager()),
+ ],
+ ),
+ ],
+ [
+ migrations.CreateModel(
+ "Foo",
+ fields=[],
+ managers=[
+ ("objects", models.Manager()),
+ ("things", models.Manager()),
+ ],
+ ),
+ ],
+ )
+
+ def test_create_model_and_remove_model_options(self):
+ self.assertOptimizesTo(
+ [
+ migrations.CreateModel(
+ "MyModel",
+ fields=[],
+ options={"verbose_name": "My Model"},
+ ),
+ migrations.AlterModelOptions("MyModel", options={}),
+ ],
+ [migrations.CreateModel("MyModel", fields=[])],
+ )
+ self.assertOptimizesTo(
+ [
+ migrations.CreateModel(
+ "MyModel",
+ fields=[],
+ options={
+ "verbose_name": "My Model",
+ "verbose_name_plural": "My Model plural",
+ },
+ ),
+ migrations.AlterModelOptions(
+ "MyModel",
+ options={"verbose_name": "My Model"},
+ ),
+ ],
+ [
+ migrations.CreateModel(
+ "MyModel",
+ fields=[],
+ options={"verbose_name": "My Model"},
+ ),
+ ],
+ )
+
+ def _test_create_alter_foo_delete_model(self, alter_foo):
+ """
+ CreateModel, AlterModelTable, AlterUniqueTogether/AlterIndexTogether/
+ AlterOrderWithRespectTo, and DeleteModel should collapse into nothing.
+ """
+ self.assertOptimizesTo(
+ [
+ migrations.CreateModel(
+ "Foo", [("name", models.CharField(max_length=255))]
+ ),
+ migrations.AlterModelTable("Foo", "woohoo"),
+ alter_foo,
+ migrations.DeleteModel("Foo"),
+ ],
+ [],
+ )
+
+ def test_create_alter_unique_delete_model(self):
+ self._test_create_alter_foo_delete_model(
+ migrations.AlterUniqueTogether("Foo", [["a", "b"]])
+ )
+
+ def test_create_alter_index_delete_model(self):
+ self._test_create_alter_foo_delete_model(
+ migrations.AlterIndexTogether("Foo", [["a", "b"]])
+ )
+
+ def test_create_alter_owrt_delete_model(self):
+ self._test_create_alter_foo_delete_model(
+ migrations.AlterOrderWithRespectTo("Foo", "a")
+ )
+
+ def _test_alter_alter(self, alter_foo, alter_bar):
+ """
+ Two AlterUniqueTogether/AlterIndexTogether/AlterOrderWithRespectTo
+ /AlterField should collapse into the second.
+ """
+ self.assertOptimizesTo(
+ [
+ alter_foo,
+ alter_bar,
+ ],
+ [
+ alter_bar,
+ ],
+ )
+
+ def test_alter_alter_table_model(self):
+ self._test_alter_alter(
+ migrations.AlterModelTable("Foo", "a"),
+ migrations.AlterModelTable("Foo", "b"),
+ )
+
+ def test_alter_alter_unique_model(self):
+ self._test_alter_alter(
+ migrations.AlterUniqueTogether("Foo", [["a", "b"]]),
+ migrations.AlterUniqueTogether("Foo", [["a", "c"]]),
+ )
+
+ def test_alter_alter_index_model(self):
+ self._test_alter_alter(
+ migrations.AlterIndexTogether("Foo", [["a", "b"]]),
+ migrations.AlterIndexTogether("Foo", [["a", "c"]]),
+ )
+
+ def test_alter_alter_owrt_model(self):
+ self._test_alter_alter(
+ migrations.AlterOrderWithRespectTo("Foo", "a"),
+ migrations.AlterOrderWithRespectTo("Foo", "b"),
+ )
+
+ def test_alter_alter_field(self):
+ self._test_alter_alter(
+ migrations.AlterField("Foo", "name", models.IntegerField()),
+ migrations.AlterField("Foo", "name", models.IntegerField(help_text="help")),
+ )
+
+ def test_optimize_through_create(self):
+ """
+ We should be able to optimize away create/delete through a create or
+ delete of a different model, but only if the create operation does not
+ mention the model at all.
+ """
+ # These should work
+ self.assertOptimizesTo(
+ [
+ migrations.CreateModel(
+ "Foo", [("name", models.CharField(max_length=255))]
+ ),
+ migrations.CreateModel("Bar", [("size", models.IntegerField())]),
+ migrations.DeleteModel("Foo"),
+ ],
+ [
+ migrations.CreateModel("Bar", [("size", models.IntegerField())]),
+ ],
+ )
+ self.assertOptimizesTo(
+ [
+ migrations.CreateModel(
+ "Foo", [("name", models.CharField(max_length=255))]
+ ),
+ migrations.CreateModel("Bar", [("size", models.IntegerField())]),
+ migrations.DeleteModel("Bar"),
+ migrations.DeleteModel("Foo"),
+ ],
+ [],
+ )
+ self.assertOptimizesTo(
+ [
+ migrations.CreateModel(
+ "Foo", [("name", models.CharField(max_length=255))]
+ ),
+ migrations.CreateModel("Bar", [("size", models.IntegerField())]),
+ migrations.DeleteModel("Foo"),
+ migrations.DeleteModel("Bar"),
+ ],
+ [],
+ )
+ # Operations should be optimized if the FK references a model from the
+ # other app.
+ self.assertOptimizesTo(
+ [
+ migrations.CreateModel(
+ "Foo", [("name", models.CharField(max_length=255))]
+ ),
+ migrations.CreateModel(
+ "Bar", [("other", models.ForeignKey("testapp.Foo", models.CASCADE))]
+ ),
+ migrations.DeleteModel("Foo"),
+ ],
+ [
+ migrations.CreateModel(
+ "Bar", [("other", models.ForeignKey("testapp.Foo", models.CASCADE))]
+ ),
+ ],
+ app_label="otherapp",
+ )
+ # But it shouldn't work if a FK references a model with the same
+ # app_label.
+ self.assertDoesNotOptimize(
+ [
+ migrations.CreateModel(
+ "Foo", [("name", models.CharField(max_length=255))]
+ ),
+ migrations.CreateModel(
+ "Bar", [("other", models.ForeignKey("Foo", models.CASCADE))]
+ ),
+ migrations.DeleteModel("Foo"),
+ ],
+ )
+ self.assertDoesNotOptimize(
+ [
+ migrations.CreateModel(
+ "Foo", [("name", models.CharField(max_length=255))]
+ ),
+ migrations.CreateModel(
+ "Bar", [("other", models.ForeignKey("testapp.Foo", models.CASCADE))]
+ ),
+ migrations.DeleteModel("Foo"),
+ ],
+ app_label="testapp",
+ )
+ # This should not work - bases should block it
+ self.assertDoesNotOptimize(
+ [
+ migrations.CreateModel(
+ "Foo", [("name", models.CharField(max_length=255))]
+ ),
+ migrations.CreateModel(
+ "Bar", [("size", models.IntegerField())], bases=("Foo",)
+ ),
+ migrations.DeleteModel("Foo"),
+ ],
+ )
+ self.assertDoesNotOptimize(
+ [
+ migrations.CreateModel(
+ "Foo", [("name", models.CharField(max_length=255))]
+ ),
+ migrations.CreateModel(
+ "Bar", [("size", models.IntegerField())], bases=("testapp.Foo",)
+ ),
+ migrations.DeleteModel("Foo"),
+ ],
+ app_label="testapp",
+ )
+ # The same operations should be optimized if app_label and none of
+ # bases belong to that app.
+ self.assertOptimizesTo(
+ [
+ migrations.CreateModel(
+ "Foo", [("name", models.CharField(max_length=255))]
+ ),
+ migrations.CreateModel(
+ "Bar", [("size", models.IntegerField())], bases=("testapp.Foo",)
+ ),
+ migrations.DeleteModel("Foo"),
+ ],
+ [
+ migrations.CreateModel(
+ "Bar", [("size", models.IntegerField())], bases=("testapp.Foo",)
+ ),
+ ],
+ app_label="otherapp",
+ )
+ # But it shouldn't work if some of bases belongs to the specified app.
+ self.assertDoesNotOptimize(
+ [
+ migrations.CreateModel(
+ "Foo", [("name", models.CharField(max_length=255))]
+ ),
+ migrations.CreateModel(
+ "Bar", [("size", models.IntegerField())], bases=("testapp.Foo",)
+ ),
+ migrations.DeleteModel("Foo"),
+ ],
+ app_label="testapp",
+ )
+
+ self.assertOptimizesTo(
+ [
+ migrations.CreateModel(
+ "Book", [("name", models.CharField(max_length=255))]
+ ),
+ migrations.CreateModel(
+ "Person", [("name", models.CharField(max_length=255))]
+ ),
+ migrations.AddField(
+ "book",
+ "author",
+ models.ForeignKey("test_app.Person", models.CASCADE),
+ ),
+ migrations.CreateModel(
+ "Review",
+ [("book", models.ForeignKey("test_app.Book", models.CASCADE))],
+ ),
+ migrations.CreateModel(
+ "Reviewer", [("name", models.CharField(max_length=255))]
+ ),
+ migrations.AddField(
+ "review",
+ "reviewer",
+ models.ForeignKey("test_app.Reviewer", models.CASCADE),
+ ),
+ migrations.RemoveField("book", "author"),
+ migrations.DeleteModel("Person"),
+ ],
+ [
+ migrations.CreateModel(
+ "Book", [("name", models.CharField(max_length=255))]
+ ),
+ migrations.CreateModel(
+ "Reviewer", [("name", models.CharField(max_length=255))]
+ ),
+ migrations.CreateModel(
+ "Review",
+ [
+ ("book", models.ForeignKey("test_app.Book", models.CASCADE)),
+ (
+ "reviewer",
+ models.ForeignKey("test_app.Reviewer", models.CASCADE),
+ ),
+ ],
+ ),
+ ],
+ app_label="test_app",
+ )
+
+ def test_create_model_add_field(self):
+ """
+ AddField should optimize into CreateModel.
+ """
+ managers = [("objects", EmptyManager())]
+ self.assertOptimizesTo(
+ [
+ migrations.CreateModel(
+ name="Foo",
+ fields=[("name", models.CharField(max_length=255))],
+ options={"verbose_name": "Foo"},
+ bases=(UnicodeModel,),
+ managers=managers,
+ ),
+ migrations.AddField("Foo", "age", models.IntegerField()),
+ ],
+ [
+ migrations.CreateModel(
+ name="Foo",
+ fields=[
+ ("name", models.CharField(max_length=255)),
+ ("age", models.IntegerField()),
+ ],
+ options={"verbose_name": "Foo"},
+ bases=(UnicodeModel,),
+ managers=managers,
+ ),
+ ],
+ )
+
+ def test_create_model_reordering(self):
+ """
+ AddField optimizes into CreateModel if it's a FK to a model that's
+ between them (and there's no FK in the other direction), by changing
+ the order of the CreateModel operations.
+ """
+ self.assertOptimizesTo(
+ [
+ migrations.CreateModel(
+ "Foo", [("name", models.CharField(max_length=255))]
+ ),
+ migrations.CreateModel("Link", [("url", models.TextField())]),
+ migrations.AddField(
+ "Foo", "link", models.ForeignKey("migrations.Link", models.CASCADE)
+ ),
+ ],
+ [
+ migrations.CreateModel("Link", [("url", models.TextField())]),
+ migrations.CreateModel(
+ "Foo",
+ [
+ ("name", models.CharField(max_length=255)),
+ ("link", models.ForeignKey("migrations.Link", models.CASCADE)),
+ ],
+ ),
+ ],
+ )
+
+ def test_create_model_reordering_circular_fk(self):
+ """
+ CreateModel reordering behavior doesn't result in an infinite loop if
+ there are FKs in both directions.
+ """
+ self.assertOptimizesTo(
+ [
+ migrations.CreateModel("Bar", [("url", models.TextField())]),
+ migrations.CreateModel(
+ "Foo", [("name", models.CharField(max_length=255))]
+ ),
+ migrations.AddField(
+ "Bar", "foo_fk", models.ForeignKey("migrations.Foo", models.CASCADE)
+ ),
+ migrations.AddField(
+ "Foo", "bar_fk", models.ForeignKey("migrations.Bar", models.CASCADE)
+ ),
+ ],
+ [
+ migrations.CreateModel(
+ "Foo", [("name", models.CharField(max_length=255))]
+ ),
+ migrations.CreateModel(
+ "Bar",
+ [
+ ("url", models.TextField()),
+ ("foo_fk", models.ForeignKey("migrations.Foo", models.CASCADE)),
+ ],
+ ),
+ migrations.AddField(
+ "Foo", "bar_fk", models.ForeignKey("migrations.Bar", models.CASCADE)
+ ),
+ ],
+ )
+
+ def test_create_model_no_reordering_for_unrelated_fk(self):
+ """
+ CreateModel order remains unchanged if the later AddField operation
+ isn't a FK between them.
+ """
+ self.assertDoesNotOptimize(
+ [
+ migrations.CreateModel(
+ "Foo", [("name", models.CharField(max_length=255))]
+ ),
+ migrations.CreateModel("Link", [("url", models.TextField())]),
+ migrations.AddField(
+ "Other",
+ "link",
+ models.ForeignKey("migrations.Link", models.CASCADE),
+ ),
+ ],
+ )
+
+ def test_create_model_no_reordering_of_inherited_model(self):
+ """
+ A CreateModel that inherits from another isn't reordered to avoid
+ moving it earlier than its parent CreateModel operation.
+ """
+ self.assertOptimizesTo(
+ [
+ migrations.CreateModel(
+ "Other", [("foo", models.CharField(max_length=255))]
+ ),
+ migrations.CreateModel(
+ "ParentModel", [("bar", models.CharField(max_length=255))]
+ ),
+ migrations.CreateModel(
+ "ChildModel",
+ [("baz", models.CharField(max_length=255))],
+ bases=("migrations.parentmodel",),
+ ),
+ migrations.AddField(
+ "Other",
+ "fk",
+ models.ForeignKey("migrations.ChildModel", models.CASCADE),
+ ),
+ ],
+ [
+ migrations.CreateModel(
+ "ParentModel", [("bar", models.CharField(max_length=255))]
+ ),
+ migrations.CreateModel(
+ "ChildModel",
+ [("baz", models.CharField(max_length=255))],
+ bases=("migrations.parentmodel",),
+ ),
+ migrations.CreateModel(
+ "Other",
+ [
+ ("foo", models.CharField(max_length=255)),
+ (
+ "fk",
+ models.ForeignKey("migrations.ChildModel", models.CASCADE),
+ ),
+ ],
+ ),
+ ],
+ )
+
+ def test_create_model_add_field_not_through_m2m_through(self):
+ """
+ AddField should NOT optimize into CreateModel if it's an M2M using a
+ through that's created between them.
+ """
+ self.assertDoesNotOptimize(
+ [
+ migrations.CreateModel("Employee", []),
+ migrations.CreateModel("Employer", []),
+ migrations.CreateModel(
+ "Employment",
+ [
+ (
+ "employee",
+ models.ForeignKey("migrations.Employee", models.CASCADE),
+ ),
+ (
+ "employment",
+ models.ForeignKey("migrations.Employer", models.CASCADE),
+ ),
+ ],
+ ),
+ migrations.AddField(
+ "Employer",
+ "employees",
+ models.ManyToManyField(
+ "migrations.Employee",
+ through="migrations.Employment",
+ ),
+ ),
+ ],
+ )
+
+ def test_create_model_alter_field(self):
+ """
+ AlterField should optimize into CreateModel.
+ """
+ managers = [("objects", EmptyManager())]
+ self.assertOptimizesTo(
+ [
+ migrations.CreateModel(
+ name="Foo",
+ fields=[("name", models.CharField(max_length=255))],
+ options={"verbose_name": "Foo"},
+ bases=(UnicodeModel,),
+ managers=managers,
+ ),
+ migrations.AlterField("Foo", "name", models.IntegerField()),
+ ],
+ [
+ migrations.CreateModel(
+ name="Foo",
+ fields=[
+ ("name", models.IntegerField()),
+ ],
+ options={"verbose_name": "Foo"},
+ bases=(UnicodeModel,),
+ managers=managers,
+ ),
+ ],
+ )
+
+ def test_create_model_rename_field(self):
+ """
+ RenameField should optimize into CreateModel.
+ """
+ managers = [("objects", EmptyManager())]
+ self.assertOptimizesTo(
+ [
+ migrations.CreateModel(
+ name="Foo",
+ fields=[("name", models.CharField(max_length=255))],
+ options={"verbose_name": "Foo"},
+ bases=(UnicodeModel,),
+ managers=managers,
+ ),
+ migrations.RenameField("Foo", "name", "title"),
+ ],
+ [
+ migrations.CreateModel(
+ name="Foo",
+ fields=[
+ ("title", models.CharField(max_length=255)),
+ ],
+ options={"verbose_name": "Foo"},
+ bases=(UnicodeModel,),
+ managers=managers,
+ ),
+ ],
+ )
+
+ def test_add_field_rename_field(self):
+ """
+ RenameField should optimize into AddField
+ """
+ self.assertOptimizesTo(
+ [
+ migrations.AddField("Foo", "name", models.CharField(max_length=255)),
+ migrations.RenameField("Foo", "name", "title"),
+ ],
+ [
+ migrations.AddField("Foo", "title", models.CharField(max_length=255)),
+ ],
+ )
+
+ def test_alter_field_rename_field(self):
+ """
+ RenameField should optimize to the other side of AlterField,
+ and into itself.
+ """
+ self.assertOptimizesTo(
+ [
+ migrations.AlterField("Foo", "name", models.CharField(max_length=255)),
+ migrations.RenameField("Foo", "name", "title"),
+ migrations.RenameField("Foo", "title", "nom"),
+ ],
+ [
+ migrations.RenameField("Foo", "name", "nom"),
+ migrations.AlterField("Foo", "nom", models.CharField(max_length=255)),
+ ],
+ )
+
+ def test_swapping_fields_names(self):
+ self.assertDoesNotOptimize(
+ [
+ migrations.CreateModel(
+ "MyModel",
+ [
+ ("field_a", models.IntegerField()),
+ ("field_b", models.IntegerField()),
+ ],
+ ),
+ migrations.RunPython(migrations.RunPython.noop),
+ migrations.RenameField("MyModel", "field_a", "field_c"),
+ migrations.RenameField("MyModel", "field_b", "field_a"),
+ migrations.RenameField("MyModel", "field_c", "field_b"),
+ ],
+ )
+
+ def test_create_model_remove_field(self):
+ """
+ RemoveField should optimize into CreateModel.
+ """
+ managers = [("objects", EmptyManager())]
+ self.assertOptimizesTo(
+ [
+ migrations.CreateModel(
+ name="Foo",
+ fields=[
+ ("name", models.CharField(max_length=255)),
+ ("age", models.IntegerField()),
+ ],
+ options={"verbose_name": "Foo"},
+ bases=(UnicodeModel,),
+ managers=managers,
+ ),
+ migrations.RemoveField("Foo", "age"),
+ ],
+ [
+ migrations.CreateModel(
+ name="Foo",
+ fields=[
+ ("name", models.CharField(max_length=255)),
+ ],
+ options={"verbose_name": "Foo"},
+ bases=(UnicodeModel,),
+ managers=managers,
+ ),
+ ],
+ )
+
+ def test_add_field_alter_field(self):
+ """
+ AlterField should optimize into AddField.
+ """
+ self.assertOptimizesTo(
+ [
+ migrations.AddField("Foo", "age", models.IntegerField()),
+ migrations.AlterField("Foo", "age", models.FloatField(default=2.4)),
+ ],
+ [
+ migrations.AddField(
+ "Foo", name="age", field=models.FloatField(default=2.4)
+ ),
+ ],
+ )
+
+ def test_add_field_delete_field(self):
+ """
+ RemoveField should cancel AddField
+ """
+ self.assertOptimizesTo(
+ [
+ migrations.AddField("Foo", "age", models.IntegerField()),
+ migrations.RemoveField("Foo", "age"),
+ ],
+ [],
+ )
+
+ def test_alter_field_delete_field(self):
+ """
+ RemoveField should absorb AlterField
+ """
+ self.assertOptimizesTo(
+ [
+ migrations.AlterField("Foo", "age", models.IntegerField()),
+ migrations.RemoveField("Foo", "age"),
+ ],
+ [
+ migrations.RemoveField("Foo", "age"),
+ ],
+ )
+
+ def _test_create_alter_foo_field(self, alter):
+ """
+ CreateModel, AlterFooTogether/AlterOrderWithRespectTo followed by an
+ add/alter/rename field should optimize to CreateModel with options.
+ """
+ option_value = getattr(alter, alter.option_name)
+ options = {alter.option_name: option_value}
+
+ # AddField
+ self.assertOptimizesTo(
+ [
+ migrations.CreateModel(
+ "Foo",
+ [
+ ("a", models.IntegerField()),
+ ("b", models.IntegerField()),
+ ],
+ ),
+ alter,
+ migrations.AddField("Foo", "c", models.IntegerField()),
+ ],
+ [
+ migrations.CreateModel(
+ "Foo",
+ [
+ ("a", models.IntegerField()),
+ ("b", models.IntegerField()),
+ ("c", models.IntegerField()),
+ ],
+ options=options,
+ ),
+ ],
+ )
+
+ # AlterField
+ self.assertOptimizesTo(
+ [
+ migrations.CreateModel(
+ "Foo",
+ [
+ ("a", models.IntegerField()),
+ ("b", models.IntegerField()),
+ ],
+ ),
+ alter,
+ migrations.AlterField("Foo", "b", models.CharField(max_length=255)),
+ ],
+ [
+ migrations.CreateModel(
+ "Foo",
+ [
+ ("a", models.IntegerField()),
+ ("b", models.CharField(max_length=255)),
+ ],
+ options=options,
+ ),
+ ],
+ )
+
+ self.assertOptimizesTo(
+ [
+ migrations.CreateModel(
+ "Foo",
+ [
+ ("a", models.IntegerField()),
+ ("b", models.IntegerField()),
+ ("c", models.IntegerField()),
+ ],
+ ),
+ alter,
+ migrations.AlterField("Foo", "c", models.CharField(max_length=255)),
+ ],
+ [
+ migrations.CreateModel(
+ "Foo",
+ [
+ ("a", models.IntegerField()),
+ ("b", models.IntegerField()),
+ ("c", models.CharField(max_length=255)),
+ ],
+ options=options,
+ ),
+ ],
+ )
+
+ # RenameField
+ if isinstance(option_value, str):
+ renamed_options = {alter.option_name: "c"}
+ else:
+ renamed_options = {
+ alter.option_name: {
+ tuple("c" if value == "b" else value for value in item)
+ for item in option_value
+ }
+ }
+ self.assertOptimizesTo(
+ [
+ migrations.CreateModel(
+ "Foo",
+ [
+ ("a", models.IntegerField()),
+ ("b", models.IntegerField()),
+ ],
+ ),
+ alter,
+ migrations.RenameField("Foo", "b", "c"),
+ ],
+ [
+ migrations.CreateModel(
+ "Foo",
+ [
+ ("a", models.IntegerField()),
+ ("c", models.IntegerField()),
+ ],
+ options=renamed_options,
+ ),
+ ],
+ )
+
+ self.assertOptimizesTo(
+ [
+ migrations.CreateModel(
+ "Foo",
+ [
+ ("a", models.IntegerField()),
+ ("b", models.IntegerField()),
+ ],
+ ),
+ alter,
+ migrations.RenameField("Foo", "b", "x"),
+ migrations.RenameField("Foo", "x", "c"),
+ ],
+ [
+ migrations.CreateModel(
+ "Foo",
+ [
+ ("a", models.IntegerField()),
+ ("c", models.IntegerField()),
+ ],
+ options=renamed_options,
+ ),
+ ],
+ )
+
+ self.assertOptimizesTo(
+ [
+ migrations.CreateModel(
+ "Foo",
+ [
+ ("a", models.IntegerField()),
+ ("b", models.IntegerField()),
+ ("c", models.IntegerField()),
+ ],
+ ),
+ alter,
+ migrations.RenameField("Foo", "c", "d"),
+ ],
+ [
+ migrations.CreateModel(
+ "Foo",
+ [
+ ("a", models.IntegerField()),
+ ("b", models.IntegerField()),
+ ("d", models.IntegerField()),
+ ],
+ options=options,
+ ),
+ ],
+ )
+
+ # RemoveField
+ if isinstance(option_value, str):
+ removed_options = None
+ else:
+ removed_options = {
+ alter.option_name: {
+ tuple(value for value in item if value != "b")
+ for item in option_value
+ }
+ }
+ self.assertOptimizesTo(
+ [
+ migrations.CreateModel(
+ "Foo",
+ [
+ ("a", models.IntegerField()),
+ ("b", models.IntegerField()),
+ ],
+ ),
+ alter,
+ migrations.RemoveField("Foo", "b"),
+ ],
+ [
+ migrations.CreateModel(
+ "Foo",
+ [
+ ("a", models.IntegerField()),
+ ],
+ options=removed_options,
+ ),
+ ],
+ )
+
+ self.assertOptimizesTo(
+ [
+ migrations.CreateModel(
+ "Foo",
+ [
+ ("a", models.IntegerField()),
+ ("b", models.IntegerField()),
+ ("c", models.IntegerField()),
+ ],
+ ),
+ alter,
+ migrations.RemoveField("Foo", "c"),
+ ],
+ [
+ migrations.CreateModel(
+ "Foo",
+ [
+ ("a", models.IntegerField()),
+ ("b", models.IntegerField()),
+ ],
+ options=options,
+ ),
+ ],
+ )
+
+ def test_create_alter_unique_field(self):
+ self._test_create_alter_foo_field(
+ migrations.AlterUniqueTogether("Foo", [["a", "b"]])
+ )
+
+ def test_create_alter_index_field(self):
+ self._test_create_alter_foo_field(
+ migrations.AlterIndexTogether("Foo", [["a", "b"]])
+ )
+
+ def test_create_alter_owrt_field(self):
+ self._test_create_alter_foo_field(
+ migrations.AlterOrderWithRespectTo("Foo", "b")
+ )
+
+ def test_optimize_through_fields(self):
+ """
+ field-level through checking is working. This should manage to collapse
+ model Foo to nonexistence, and model Bar to a single IntegerField
+ called "width".
+ """
+ self.assertOptimizesTo(
+ [
+ migrations.CreateModel(
+ "Foo", [("name", models.CharField(max_length=255))]
+ ),
+ migrations.CreateModel("Bar", [("size", models.IntegerField())]),
+ migrations.AddField("Foo", "age", models.IntegerField()),
+ migrations.AddField("Bar", "width", models.IntegerField()),
+ migrations.AlterField("Foo", "age", models.IntegerField()),
+ migrations.RenameField("Bar", "size", "dimensions"),
+ migrations.RemoveField("Foo", "age"),
+ migrations.RenameModel("Foo", "Phou"),
+ migrations.RemoveField("Bar", "dimensions"),
+ migrations.RenameModel("Phou", "Fou"),
+ migrations.DeleteModel("Fou"),
+ ],
+ [
+ migrations.CreateModel("Bar", [("width", models.IntegerField())]),
+ ],
+ )
+
+ def test_optimize_elidable_operation(self):
+ elidable_operation = operations.base.Operation()
+ elidable_operation.elidable = True
+ self.assertOptimizesTo(
+ [
+ elidable_operation,
+ migrations.CreateModel(
+ "Foo", [("name", models.CharField(max_length=255))]
+ ),
+ elidable_operation,
+ migrations.CreateModel("Bar", [("size", models.IntegerField())]),
+ elidable_operation,
+ migrations.RenameModel("Foo", "Phou"),
+ migrations.DeleteModel("Bar"),
+ elidable_operation,
+ ],
+ [
+ migrations.CreateModel(
+ "Phou", [("name", models.CharField(max_length=255))]
+ ),
+ ],
+ )
+
+ def test_rename_index(self):
+ self.assertOptimizesTo(
+ [
+ migrations.RenameIndex(
+ "Pony", new_name="mid_name", old_fields=("weight", "pink")
+ ),
+ migrations.RenameIndex(
+ "Pony", new_name="new_name", old_name="mid_name"
+ ),
+ ],
+ [
+ migrations.RenameIndex(
+ "Pony", new_name="new_name", old_fields=("weight", "pink")
+ ),
+ ],
+ )
+ self.assertOptimizesTo(
+ [
+ migrations.RenameIndex(
+ "Pony", new_name="mid_name", old_name="old_name"
+ ),
+ migrations.RenameIndex(
+ "Pony", new_name="new_name", old_name="mid_name"
+ ),
+ ],
+ [migrations.RenameIndex("Pony", new_name="new_name", old_name="old_name")],
+ )
+ self.assertDoesNotOptimize(
+ [
+ migrations.RenameIndex(
+ "Pony", new_name="mid_name", old_name="old_name"
+ ),
+ migrations.RenameIndex(
+ "Pony", new_name="new_name", old_fields=("weight", "pink")
+ ),
+ ]
+ )
+
+ def test_add_rename_index(self):
+ tests = [
+ models.Index(fields=["weight", "pink"], name="mid_name"),
+ models.Index(Abs("weight"), name="mid_name"),
+ models.Index(
+ Abs("weight"), name="mid_name", condition=models.Q(weight__gt=0)
+ ),
+ ]
+ for index in tests:
+ with self.subTest(index=index):
+ renamed_index = index.clone()
+ renamed_index.name = "new_name"
+ self.assertOptimizesTo(
+ [
+ migrations.AddIndex("Pony", index),
+ migrations.RenameIndex(
+ "Pony", new_name="new_name", old_name="mid_name"
+ ),
+ ],
+ [
+ migrations.AddIndex("Pony", renamed_index),
+ ],
+ )
+ self.assertDoesNotOptimize(
+ [
+ migrations.AddIndex("Pony", index),
+ migrations.RenameIndex(
+ "Pony", new_name="new_name", old_name="other_name"
+ ),
+ ],
+ )
+
+ def test_add_remove_index(self):
+ self.assertOptimizesTo(
+ [
+ migrations.AddIndex(
+ "Pony",
+ models.Index(
+ fields=["weight", "pink"], name="idx_pony_weight_pink"
+ ),
+ ),
+ migrations.RemoveIndex("Pony", "idx_pony_weight_pink"),
+ ],
+ [],
+ )
+
+ def test_add_remove_constraint(self):
+ gt_constraint = models.CheckConstraint(
+ check=models.Q(pink__gt=2), name="constraint_pony_pink_gt_2"
+ )
+ self.assertOptimizesTo(
+ [
+ migrations.AddConstraint("Pony", gt_constraint),
+ migrations.RemoveConstraint("Pony", gt_constraint.name),
+ ],
+ [],
+ )
+ self.assertDoesNotOptimize(
+ [
+ migrations.AddConstraint("Pony", gt_constraint),
+ migrations.RemoveConstraint("Pony", "other_name"),
+ ],
+ )
+
+ def test_create_model_add_index(self):
+ self.assertOptimizesTo(
+ [
+ migrations.CreateModel(
+ name="Pony",
+ fields=[
+ ("weight", models.IntegerField()),
+ ("age", models.IntegerField()),
+ ],
+ options={
+ "indexes": [models.Index(fields=["age"], name="idx_pony_age")],
+ },
+ ),
+ migrations.AddIndex(
+ "Pony",
+ models.Index(fields=["weight"], name="idx_pony_weight"),
+ ),
+ ],
+ [
+ migrations.CreateModel(
+ name="Pony",
+ fields=[
+ ("weight", models.IntegerField()),
+ ("age", models.IntegerField()),
+ ],
+ options={
+ "indexes": [
+ models.Index(fields=["age"], name="idx_pony_age"),
+ models.Index(fields=["weight"], name="idx_pony_weight"),
+ ],
+ },
+ ),
+ ],
+ )
+
+ def test_create_model_remove_index(self):
+ self.assertOptimizesTo(
+ [
+ migrations.CreateModel(
+ name="Pony",
+ fields=[
+ ("weight", models.IntegerField()),
+ ("age", models.IntegerField()),
+ ],
+ options={
+ "indexes": [
+ models.Index(fields=["age"], name="idx_pony_age"),
+ models.Index(fields=["weight"], name="idx_pony_weight"),
+ ],
+ },
+ ),
+ migrations.RemoveIndex("Pony", "idx_pony_age"),
+ ],
+ [
+ migrations.CreateModel(
+ name="Pony",
+ fields=[
+ ("weight", models.IntegerField()),
+ ("age", models.IntegerField()),
+ ],
+ options={
+ "indexes": [
+ models.Index(fields=["weight"], name="idx_pony_weight"),
+ ],
+ },
+ ),
+ ],
+ )
+
+ def test_create_model_remove_index_together_rename_index(self):
+ self.assertOptimizesTo(
+ [
+ migrations.CreateModel(
+ name="Pony",
+ fields=[
+ ("weight", models.IntegerField()),
+ ("age", models.IntegerField()),
+ ],
+ options={
+ "index_together": [("age", "weight")],
+ },
+ ),
+ migrations.RenameIndex(
+ "Pony", new_name="idx_pony_age_weight", old_fields=("age", "weight")
+ ),
+ ],
+ [
+ migrations.CreateModel(
+ name="Pony",
+ fields=[
+ ("weight", models.IntegerField()),
+ ("age", models.IntegerField()),
+ ],
+ options={
+ "indexes": [
+ models.Index(
+ fields=["age", "weight"], name="idx_pony_age_weight"
+ ),
+ ],
+ },
+ ),
+ ],
+ )
+
+ def test_create_model_index_together_rename_index(self):
+ self.assertOptimizesTo(
+ [
+ migrations.CreateModel(
+ name="Pony",
+ fields=[
+ ("weight", models.IntegerField()),
+ ("age", models.IntegerField()),
+ ("height", models.IntegerField()),
+ ("rank", models.IntegerField()),
+ ],
+ options={
+ "index_together": [("age", "weight"), ("height", "rank")],
+ },
+ ),
+ migrations.RenameIndex(
+ "Pony", new_name="idx_pony_age_weight", old_fields=("age", "weight")
+ ),
+ ],
+ [
+ migrations.CreateModel(
+ name="Pony",
+ fields=[
+ ("weight", models.IntegerField()),
+ ("age", models.IntegerField()),
+ ("height", models.IntegerField()),
+ ("rank", models.IntegerField()),
+ ],
+ options={
+ "index_together": {("height", "rank")},
+ "indexes": [
+ models.Index(
+ fields=["age", "weight"], name="idx_pony_age_weight"
+ ),
+ ],
+ },
+ ),
+ ],
+ )
+
+ def test_create_model_rename_index_no_old_fields(self):
+ self.assertOptimizesTo(
+ [
+ migrations.CreateModel(
+ name="Pony",
+ fields=[
+ ("weight", models.IntegerField()),
+ ("age", models.IntegerField()),
+ ],
+ options={
+ "indexes": [models.Index(fields=["age"], name="idx_pony_age")],
+ },
+ ),
+ migrations.RenameIndex(
+ "Pony", new_name="idx_pony_age_new", old_name="idx_pony_age"
+ ),
+ ],
+ [
+ migrations.CreateModel(
+ name="Pony",
+ fields=[
+ ("weight", models.IntegerField()),
+ ("age", models.IntegerField()),
+ ],
+ options={
+ "indexes": [models.Index(fields=["age"], name="idx_pony_age")],
+ },
+ ),
+ migrations.RenameIndex(
+ "Pony", new_name="idx_pony_age_new", old_name="idx_pony_age"
+ ),
+ ],
+ )
diff --git a/testbed/django__django/tests/migrations/test_questioner.py b/testbed/django__django/tests/migrations/test_questioner.py
new file mode 100644
index 0000000000000000000000000000000000000000..c1aebcb22491a8e8bafe9c80dec404ed33895708
--- /dev/null
+++ b/testbed/django__django/tests/migrations/test_questioner.py
@@ -0,0 +1,85 @@
+import datetime
+from io import StringIO
+from unittest import mock
+
+from django.core.management.base import OutputWrapper
+from django.db.migrations.questioner import (
+ InteractiveMigrationQuestioner,
+ MigrationQuestioner,
+)
+from django.db.models import NOT_PROVIDED
+from django.test import SimpleTestCase
+from django.test.utils import override_settings
+
+
+class QuestionerTests(SimpleTestCase):
+ @override_settings(
+ INSTALLED_APPS=["migrations"],
+ MIGRATION_MODULES={"migrations": None},
+ )
+ def test_ask_initial_with_disabled_migrations(self):
+ questioner = MigrationQuestioner()
+ self.assertIs(False, questioner.ask_initial("migrations"))
+
+ def test_ask_not_null_alteration(self):
+ questioner = MigrationQuestioner()
+ self.assertIsNone(
+ questioner.ask_not_null_alteration("field_name", "model_name")
+ )
+
+ @mock.patch("builtins.input", return_value="2")
+ def test_ask_not_null_alteration_not_provided(self, mock):
+ questioner = InteractiveMigrationQuestioner(
+ prompt_output=OutputWrapper(StringIO())
+ )
+ question = questioner.ask_not_null_alteration("field_name", "model_name")
+ self.assertEqual(question, NOT_PROVIDED)
+
+
+class QuestionerHelperMethodsTests(SimpleTestCase):
+ def setUp(self):
+ self.prompt = OutputWrapper(StringIO())
+ self.questioner = InteractiveMigrationQuestioner(prompt_output=self.prompt)
+
+ @mock.patch("builtins.input", return_value="datetime.timedelta(days=1)")
+ def test_questioner_default_timedelta(self, mock_input):
+ value = self.questioner._ask_default()
+ self.assertEqual(value, datetime.timedelta(days=1))
+
+ @mock.patch("builtins.input", return_value="")
+ def test_questioner_default_no_user_entry(self, mock_input):
+ value = self.questioner._ask_default(default="datetime.timedelta(days=1)")
+ self.assertEqual(value, datetime.timedelta(days=1))
+
+ @mock.patch("builtins.input", side_effect=["", "exit"])
+ def test_questioner_no_default_no_user_entry(self, mock_input):
+ with self.assertRaises(SystemExit):
+ self.questioner._ask_default()
+ self.assertIn(
+ "Please enter some code, or 'exit' (without quotes) to exit.",
+ self.prompt.getvalue(),
+ )
+
+ @mock.patch("builtins.input", side_effect=["bad code", "exit"])
+ def test_questioner_no_default_bad_user_entry_code(self, mock_input):
+ with self.assertRaises(SystemExit):
+ self.questioner._ask_default()
+ self.assertIn("Invalid input: ", self.prompt.getvalue())
+
+ @mock.patch("builtins.input", side_effect=["", "n"])
+ def test_questioner_no_default_no_user_entry_boolean(self, mock_input):
+ value = self.questioner._boolean_input("Proceed?")
+ self.assertIs(value, False)
+
+ @mock.patch("builtins.input", return_value="")
+ def test_questioner_default_no_user_entry_boolean(self, mock_input):
+ value = self.questioner._boolean_input("Proceed?", default=True)
+ self.assertIs(value, True)
+
+ @mock.patch("builtins.input", side_effect=[10, "garbage", 1])
+ def test_questioner_bad_user_choice(self, mock_input):
+ question = "Make a choice:"
+ value = self.questioner._choice_input(question, choices="abc")
+ expected_msg = f"{question}\n" f" 1) a\n" f" 2) b\n" f" 3) c\n"
+ self.assertIn(expected_msg, self.prompt.getvalue())
+ self.assertEqual(value, 1)
diff --git a/testbed/django__django/tests/migrations/test_state.py b/testbed/django__django/tests/migrations/test_state.py
new file mode 100644
index 0000000000000000000000000000000000000000..55de9b3a67227be197e18d9a40589e94ea3549f6
--- /dev/null
+++ b/testbed/django__django/tests/migrations/test_state.py
@@ -0,0 +1,2227 @@
+from django.apps.registry import Apps
+from django.contrib.contenttypes.fields import GenericForeignKey
+from django.db import models
+from django.db.migrations.exceptions import InvalidBasesError
+from django.db.migrations.operations import (
+ AddField,
+ AlterField,
+ DeleteModel,
+ RemoveField,
+)
+from django.db.migrations.state import (
+ ModelState,
+ ProjectState,
+ get_related_models_recursive,
+)
+from django.test import SimpleTestCase, ignore_warnings, override_settings
+from django.test.utils import isolate_apps
+from django.utils.deprecation import RemovedInDjango51Warning
+
+from .models import (
+ FoodManager,
+ FoodQuerySet,
+ ModelWithCustomBase,
+ NoMigrationFoodManager,
+ UnicodeModel,
+)
+
+
+class StateTests(SimpleTestCase):
+ """
+ Tests state construction, rendering and modification by operations.
+ """
+
+ # RemovedInDjango51Warning, when deprecation ends, only remove
+ # Meta.index_together from inline models.
+ @ignore_warnings(category=RemovedInDjango51Warning)
+ def test_create(self):
+ """
+ Tests making a ProjectState from an Apps
+ """
+
+ new_apps = Apps(["migrations"])
+
+ class Author(models.Model):
+ name = models.CharField(max_length=255)
+ bio = models.TextField()
+ age = models.IntegerField(blank=True, null=True)
+
+ class Meta:
+ app_label = "migrations"
+ apps = new_apps
+ unique_together = ["name", "bio"]
+ index_together = ["bio", "age"] # RemovedInDjango51Warning.
+
+ class AuthorProxy(Author):
+ class Meta:
+ app_label = "migrations"
+ apps = new_apps
+ proxy = True
+ ordering = ["name"]
+
+ class SubAuthor(Author):
+ width = models.FloatField(null=True)
+
+ class Meta:
+ app_label = "migrations"
+ apps = new_apps
+
+ class Book(models.Model):
+ title = models.CharField(max_length=1000)
+ author = models.ForeignKey(Author, models.CASCADE)
+ contributors = models.ManyToManyField(Author)
+
+ class Meta:
+ app_label = "migrations"
+ apps = new_apps
+ verbose_name = "tome"
+ db_table = "test_tome"
+ indexes = [models.Index(fields=["title"])]
+
+ class Food(models.Model):
+ food_mgr = FoodManager("a", "b")
+ food_qs = FoodQuerySet.as_manager()
+ food_no_mgr = NoMigrationFoodManager("x", "y")
+
+ class Meta:
+ app_label = "migrations"
+ apps = new_apps
+
+ class FoodNoManagers(models.Model):
+ class Meta:
+ app_label = "migrations"
+ apps = new_apps
+
+ class FoodNoDefaultManager(models.Model):
+ food_no_mgr = NoMigrationFoodManager("x", "y")
+ food_mgr = FoodManager("a", "b")
+ food_qs = FoodQuerySet.as_manager()
+
+ class Meta:
+ app_label = "migrations"
+ apps = new_apps
+
+ mgr1 = FoodManager("a", "b")
+ mgr2 = FoodManager("x", "y", c=3, d=4)
+
+ class FoodOrderedManagers(models.Model):
+ # The managers on this model should be ordered by their creation
+ # counter and not by the order in model body
+
+ food_no_mgr = NoMigrationFoodManager("x", "y")
+ food_mgr2 = mgr2
+ food_mgr1 = mgr1
+
+ class Meta:
+ app_label = "migrations"
+ apps = new_apps
+
+ project_state = ProjectState.from_apps(new_apps)
+ author_state = project_state.models["migrations", "author"]
+ author_proxy_state = project_state.models["migrations", "authorproxy"]
+ sub_author_state = project_state.models["migrations", "subauthor"]
+ book_state = project_state.models["migrations", "book"]
+ food_state = project_state.models["migrations", "food"]
+ food_no_managers_state = project_state.models["migrations", "foodnomanagers"]
+ food_no_default_manager_state = project_state.models[
+ "migrations", "foodnodefaultmanager"
+ ]
+ food_order_manager_state = project_state.models[
+ "migrations", "foodorderedmanagers"
+ ]
+ book_index = models.Index(fields=["title"])
+ book_index.set_name_with_model(Book)
+
+ self.assertEqual(author_state.app_label, "migrations")
+ self.assertEqual(author_state.name, "Author")
+ self.assertEqual(list(author_state.fields), ["id", "name", "bio", "age"])
+ self.assertEqual(author_state.fields["name"].max_length, 255)
+ self.assertIs(author_state.fields["bio"].null, False)
+ self.assertIs(author_state.fields["age"].null, True)
+ self.assertEqual(
+ author_state.options,
+ {
+ "unique_together": {("name", "bio")},
+ "index_together": {("bio", "age")}, # RemovedInDjango51Warning.
+ "indexes": [],
+ "constraints": [],
+ },
+ )
+ self.assertEqual(author_state.bases, (models.Model,))
+
+ self.assertEqual(book_state.app_label, "migrations")
+ self.assertEqual(book_state.name, "Book")
+ self.assertEqual(
+ list(book_state.fields), ["id", "title", "author", "contributors"]
+ )
+ self.assertEqual(book_state.fields["title"].max_length, 1000)
+ self.assertIs(book_state.fields["author"].null, False)
+ self.assertEqual(
+ book_state.fields["contributors"].__class__.__name__, "ManyToManyField"
+ )
+ self.assertEqual(
+ book_state.options,
+ {
+ "verbose_name": "tome",
+ "db_table": "test_tome",
+ "indexes": [book_index],
+ "constraints": [],
+ },
+ )
+ self.assertEqual(book_state.bases, (models.Model,))
+
+ self.assertEqual(author_proxy_state.app_label, "migrations")
+ self.assertEqual(author_proxy_state.name, "AuthorProxy")
+ self.assertEqual(author_proxy_state.fields, {})
+ self.assertEqual(
+ author_proxy_state.options,
+ {"proxy": True, "ordering": ["name"], "indexes": [], "constraints": []},
+ )
+ self.assertEqual(author_proxy_state.bases, ("migrations.author",))
+
+ self.assertEqual(sub_author_state.app_label, "migrations")
+ self.assertEqual(sub_author_state.name, "SubAuthor")
+ self.assertEqual(len(sub_author_state.fields), 2)
+ self.assertEqual(sub_author_state.bases, ("migrations.author",))
+
+ # The default manager is used in migrations
+ self.assertEqual([name for name, mgr in food_state.managers], ["food_mgr"])
+ self.assertTrue(all(isinstance(name, str) for name, mgr in food_state.managers))
+ self.assertEqual(food_state.managers[0][1].args, ("a", "b", 1, 2))
+
+ # No explicit managers defined. Migrations will fall back to the default
+ self.assertEqual(food_no_managers_state.managers, [])
+
+ # food_mgr is used in migration but isn't the default mgr, hence add the
+ # default
+ self.assertEqual(
+ [name for name, mgr in food_no_default_manager_state.managers],
+ ["food_no_mgr", "food_mgr"],
+ )
+ self.assertTrue(
+ all(
+ isinstance(name, str)
+ for name, mgr in food_no_default_manager_state.managers
+ )
+ )
+ self.assertEqual(
+ food_no_default_manager_state.managers[0][1].__class__, models.Manager
+ )
+ self.assertIsInstance(food_no_default_manager_state.managers[1][1], FoodManager)
+
+ self.assertEqual(
+ [name for name, mgr in food_order_manager_state.managers],
+ ["food_mgr1", "food_mgr2"],
+ )
+ self.assertTrue(
+ all(
+ isinstance(name, str) for name, mgr in food_order_manager_state.managers
+ )
+ )
+ self.assertEqual(
+ [mgr.args for name, mgr in food_order_manager_state.managers],
+ [("a", "b", 1, 2), ("x", "y", 3, 4)],
+ )
+
+ def test_custom_default_manager_added_to_the_model_state(self):
+ """
+ When the default manager of the model is a custom manager,
+ it needs to be added to the model state.
+ """
+ new_apps = Apps(["migrations"])
+ custom_manager = models.Manager()
+
+ class Author(models.Model):
+ objects = models.TextField()
+ authors = custom_manager
+
+ class Meta:
+ app_label = "migrations"
+ apps = new_apps
+
+ project_state = ProjectState.from_apps(new_apps)
+ author_state = project_state.models["migrations", "author"]
+ self.assertEqual(author_state.managers, [("authors", custom_manager)])
+
+ def test_custom_default_manager_named_objects_with_false_migration_flag(self):
+ """
+ When a manager is added with a name of 'objects' but it does not
+ have `use_in_migrations = True`, no migration should be added to the
+ model state (#26643).
+ """
+ new_apps = Apps(["migrations"])
+
+ class Author(models.Model):
+ objects = models.Manager()
+
+ class Meta:
+ app_label = "migrations"
+ apps = new_apps
+
+ project_state = ProjectState.from_apps(new_apps)
+ author_state = project_state.models["migrations", "author"]
+ self.assertEqual(author_state.managers, [])
+
+ def test_no_duplicate_managers(self):
+ """
+ When a manager is added with `use_in_migrations = True` and a parent
+ model had a manager with the same name and `use_in_migrations = True`,
+ the parent's manager shouldn't appear in the model state (#26881).
+ """
+ new_apps = Apps(["migrations"])
+
+ class PersonManager(models.Manager):
+ use_in_migrations = True
+
+ class Person(models.Model):
+ objects = PersonManager()
+
+ class Meta:
+ abstract = True
+
+ class BossManager(PersonManager):
+ use_in_migrations = True
+
+ class Boss(Person):
+ objects = BossManager()
+
+ class Meta:
+ app_label = "migrations"
+ apps = new_apps
+
+ project_state = ProjectState.from_apps(new_apps)
+ boss_state = project_state.models["migrations", "boss"]
+ self.assertEqual(boss_state.managers, [("objects", Boss.objects)])
+
+ def test_custom_default_manager(self):
+ new_apps = Apps(["migrations"])
+
+ class Author(models.Model):
+ manager1 = models.Manager()
+ manager2 = models.Manager()
+
+ class Meta:
+ app_label = "migrations"
+ apps = new_apps
+ default_manager_name = "manager2"
+
+ project_state = ProjectState.from_apps(new_apps)
+ author_state = project_state.models["migrations", "author"]
+ self.assertEqual(author_state.options["default_manager_name"], "manager2")
+ self.assertEqual(author_state.managers, [("manager2", Author.manager1)])
+
+ def test_custom_base_manager(self):
+ new_apps = Apps(["migrations"])
+
+ class Author(models.Model):
+ manager1 = models.Manager()
+ manager2 = models.Manager()
+
+ class Meta:
+ app_label = "migrations"
+ apps = new_apps
+ base_manager_name = "manager2"
+
+ class Author2(models.Model):
+ manager1 = models.Manager()
+ manager2 = models.Manager()
+
+ class Meta:
+ app_label = "migrations"
+ apps = new_apps
+ base_manager_name = "manager1"
+
+ project_state = ProjectState.from_apps(new_apps)
+
+ author_state = project_state.models["migrations", "author"]
+ self.assertEqual(author_state.options["base_manager_name"], "manager2")
+ self.assertEqual(
+ author_state.managers,
+ [
+ ("manager1", Author.manager1),
+ ("manager2", Author.manager2),
+ ],
+ )
+
+ author2_state = project_state.models["migrations", "author2"]
+ self.assertEqual(author2_state.options["base_manager_name"], "manager1")
+ self.assertEqual(
+ author2_state.managers,
+ [
+ ("manager1", Author2.manager1),
+ ],
+ )
+
+ def test_apps_bulk_update(self):
+ """
+ StateApps.bulk_update() should update apps.ready to False and reset
+ the value afterward.
+ """
+ project_state = ProjectState()
+ apps = project_state.apps
+ with apps.bulk_update():
+ self.assertFalse(apps.ready)
+ self.assertTrue(apps.ready)
+ with self.assertRaises(ValueError):
+ with apps.bulk_update():
+ self.assertFalse(apps.ready)
+ raise ValueError()
+ self.assertTrue(apps.ready)
+
+ def test_render(self):
+ """
+ Tests rendering a ProjectState into an Apps.
+ """
+ project_state = ProjectState()
+ project_state.add_model(
+ ModelState(
+ app_label="migrations",
+ name="Tag",
+ fields=[
+ ("id", models.AutoField(primary_key=True)),
+ ("name", models.CharField(max_length=100)),
+ ("hidden", models.BooleanField()),
+ ],
+ )
+ )
+ project_state.add_model(
+ ModelState(
+ app_label="migrations",
+ name="SubTag",
+ fields=[
+ (
+ "tag_ptr",
+ models.OneToOneField(
+ "migrations.Tag",
+ models.CASCADE,
+ auto_created=True,
+ parent_link=True,
+ primary_key=True,
+ to_field="id",
+ serialize=False,
+ ),
+ ),
+ ("awesome", models.BooleanField()),
+ ],
+ bases=("migrations.Tag",),
+ )
+ )
+
+ base_mgr = models.Manager()
+ mgr1 = FoodManager("a", "b")
+ mgr2 = FoodManager("x", "y", c=3, d=4)
+ project_state.add_model(
+ ModelState(
+ app_label="migrations",
+ name="Food",
+ fields=[
+ ("id", models.AutoField(primary_key=True)),
+ ],
+ managers=[
+ # The ordering we really want is objects, mgr1, mgr2
+ ("default", base_mgr),
+ ("food_mgr2", mgr2),
+ ("food_mgr1", mgr1),
+ ],
+ )
+ )
+
+ new_apps = project_state.apps
+ self.assertEqual(
+ new_apps.get_model("migrations", "Tag")._meta.get_field("name").max_length,
+ 100,
+ )
+ self.assertIs(
+ new_apps.get_model("migrations", "Tag")._meta.get_field("hidden").null,
+ False,
+ )
+
+ self.assertEqual(
+ len(new_apps.get_model("migrations", "SubTag")._meta.local_fields), 2
+ )
+
+ Food = new_apps.get_model("migrations", "Food")
+ self.assertEqual(
+ [mgr.name for mgr in Food._meta.managers],
+ ["default", "food_mgr1", "food_mgr2"],
+ )
+ self.assertTrue(all(isinstance(mgr.name, str) for mgr in Food._meta.managers))
+ self.assertEqual(
+ [mgr.__class__ for mgr in Food._meta.managers],
+ [models.Manager, FoodManager, FoodManager],
+ )
+
+ def test_render_model_inheritance(self):
+ class Book(models.Model):
+ title = models.CharField(max_length=1000)
+
+ class Meta:
+ app_label = "migrations"
+ apps = Apps()
+
+ class Novel(Book):
+ class Meta:
+ app_label = "migrations"
+ apps = Apps()
+
+ # First, test rendering individually
+ apps = Apps(["migrations"])
+
+ # We shouldn't be able to render yet
+ ms = ModelState.from_model(Novel)
+ with self.assertRaises(InvalidBasesError):
+ ms.render(apps)
+
+ # Once the parent model is in the app registry, it should be fine
+ ModelState.from_model(Book).render(apps)
+ ModelState.from_model(Novel).render(apps)
+
+ def test_render_model_with_multiple_inheritance(self):
+ class Foo(models.Model):
+ class Meta:
+ app_label = "migrations"
+ apps = Apps()
+
+ class Bar(models.Model):
+ class Meta:
+ app_label = "migrations"
+ apps = Apps()
+
+ class FooBar(Foo, Bar):
+ class Meta:
+ app_label = "migrations"
+ apps = Apps()
+
+ class AbstractSubFooBar(FooBar):
+ class Meta:
+ abstract = True
+ apps = Apps()
+
+ class SubFooBar(AbstractSubFooBar):
+ class Meta:
+ app_label = "migrations"
+ apps = Apps()
+
+ apps = Apps(["migrations"])
+
+ # We shouldn't be able to render yet
+ ms = ModelState.from_model(FooBar)
+ with self.assertRaises(InvalidBasesError):
+ ms.render(apps)
+
+ # Once the parent models are in the app registry, it should be fine
+ ModelState.from_model(Foo).render(apps)
+ self.assertSequenceEqual(ModelState.from_model(Foo).bases, [models.Model])
+ ModelState.from_model(Bar).render(apps)
+ self.assertSequenceEqual(ModelState.from_model(Bar).bases, [models.Model])
+ ModelState.from_model(FooBar).render(apps)
+ self.assertSequenceEqual(
+ ModelState.from_model(FooBar).bases, ["migrations.foo", "migrations.bar"]
+ )
+ ModelState.from_model(SubFooBar).render(apps)
+ self.assertSequenceEqual(
+ ModelState.from_model(SubFooBar).bases, ["migrations.foobar"]
+ )
+
+ def test_render_project_dependencies(self):
+ """
+ The ProjectState render method correctly renders models
+ to account for inter-model base dependencies.
+ """
+ new_apps = Apps()
+
+ class A(models.Model):
+ class Meta:
+ app_label = "migrations"
+ apps = new_apps
+
+ class B(A):
+ class Meta:
+ app_label = "migrations"
+ apps = new_apps
+
+ class C(B):
+ class Meta:
+ app_label = "migrations"
+ apps = new_apps
+
+ class D(A):
+ class Meta:
+ app_label = "migrations"
+ apps = new_apps
+
+ class E(B):
+ class Meta:
+ app_label = "migrations"
+ apps = new_apps
+ proxy = True
+
+ class F(D):
+ class Meta:
+ app_label = "migrations"
+ apps = new_apps
+ proxy = True
+
+ # Make a ProjectState and render it
+ project_state = ProjectState()
+ project_state.add_model(ModelState.from_model(A))
+ project_state.add_model(ModelState.from_model(B))
+ project_state.add_model(ModelState.from_model(C))
+ project_state.add_model(ModelState.from_model(D))
+ project_state.add_model(ModelState.from_model(E))
+ project_state.add_model(ModelState.from_model(F))
+ final_apps = project_state.apps
+ self.assertEqual(len(final_apps.get_models()), 6)
+
+ # Now make an invalid ProjectState and make sure it fails
+ project_state = ProjectState()
+ project_state.add_model(ModelState.from_model(A))
+ project_state.add_model(ModelState.from_model(B))
+ project_state.add_model(ModelState.from_model(C))
+ project_state.add_model(ModelState.from_model(F))
+ with self.assertRaises(InvalidBasesError):
+ project_state.apps
+
+ def test_render_unique_app_labels(self):
+ """
+ The ProjectState render method doesn't raise an
+ ImproperlyConfigured exception about unique labels if two dotted app
+ names have the same last part.
+ """
+
+ class A(models.Model):
+ class Meta:
+ app_label = "django.contrib.auth"
+
+ class B(models.Model):
+ class Meta:
+ app_label = "vendor.auth"
+
+ # Make a ProjectState and render it
+ project_state = ProjectState()
+ project_state.add_model(ModelState.from_model(A))
+ project_state.add_model(ModelState.from_model(B))
+ self.assertEqual(len(project_state.apps.get_models()), 2)
+
+ def test_reload_related_model_on_non_relational_fields(self):
+ """
+ The model is reloaded even on changes that are not involved in
+ relations. Other models pointing to or from it are also reloaded.
+ """
+ project_state = ProjectState()
+ project_state.apps # Render project state.
+ project_state.add_model(ModelState("migrations", "A", []))
+ project_state.add_model(
+ ModelState(
+ "migrations",
+ "B",
+ [
+ ("a", models.ForeignKey("A", models.CASCADE)),
+ ],
+ )
+ )
+ project_state.add_model(
+ ModelState(
+ "migrations",
+ "C",
+ [
+ ("b", models.ForeignKey("B", models.CASCADE)),
+ ("name", models.TextField()),
+ ],
+ )
+ )
+ project_state.add_model(
+ ModelState(
+ "migrations",
+ "D",
+ [
+ ("a", models.ForeignKey("A", models.CASCADE)),
+ ],
+ )
+ )
+ operation = AlterField(
+ model_name="C",
+ name="name",
+ field=models.TextField(blank=True),
+ )
+ operation.state_forwards("migrations", project_state)
+ project_state.reload_model("migrations", "a", delay=True)
+ A = project_state.apps.get_model("migrations.A")
+ B = project_state.apps.get_model("migrations.B")
+ D = project_state.apps.get_model("migrations.D")
+ self.assertIs(B._meta.get_field("a").related_model, A)
+ self.assertIs(D._meta.get_field("a").related_model, A)
+
+ def test_reload_model_relationship_consistency(self):
+ project_state = ProjectState()
+ project_state.add_model(ModelState("migrations", "A", []))
+ project_state.add_model(
+ ModelState(
+ "migrations",
+ "B",
+ [
+ ("a", models.ForeignKey("A", models.CASCADE)),
+ ],
+ )
+ )
+ project_state.add_model(
+ ModelState(
+ "migrations",
+ "C",
+ [
+ ("b", models.ForeignKey("B", models.CASCADE)),
+ ],
+ )
+ )
+ A = project_state.apps.get_model("migrations.A")
+ B = project_state.apps.get_model("migrations.B")
+ C = project_state.apps.get_model("migrations.C")
+ self.assertEqual([r.related_model for r in A._meta.related_objects], [B])
+ self.assertEqual([r.related_model for r in B._meta.related_objects], [C])
+ self.assertEqual([r.related_model for r in C._meta.related_objects], [])
+
+ project_state.reload_model("migrations", "a", delay=True)
+ A = project_state.apps.get_model("migrations.A")
+ B = project_state.apps.get_model("migrations.B")
+ C = project_state.apps.get_model("migrations.C")
+ self.assertEqual([r.related_model for r in A._meta.related_objects], [B])
+ self.assertEqual([r.related_model for r in B._meta.related_objects], [C])
+ self.assertEqual([r.related_model for r in C._meta.related_objects], [])
+
+ def test_add_relations(self):
+ """
+ #24573 - Adding relations to existing models should reload the
+ referenced models too.
+ """
+ new_apps = Apps()
+
+ class A(models.Model):
+ class Meta:
+ app_label = "something"
+ apps = new_apps
+
+ class B(A):
+ class Meta:
+ app_label = "something"
+ apps = new_apps
+
+ class C(models.Model):
+ class Meta:
+ app_label = "something"
+ apps = new_apps
+
+ project_state = ProjectState()
+ project_state.add_model(ModelState.from_model(A))
+ project_state.add_model(ModelState.from_model(B))
+ project_state.add_model(ModelState.from_model(C))
+
+ project_state.apps # We need to work with rendered models
+
+ old_state = project_state.clone()
+ model_a_old = old_state.apps.get_model("something", "A")
+ model_b_old = old_state.apps.get_model("something", "B")
+ model_c_old = old_state.apps.get_model("something", "C")
+ # The relations between the old models are correct
+ self.assertIs(model_a_old._meta.get_field("b").related_model, model_b_old)
+ self.assertIs(model_b_old._meta.get_field("a_ptr").related_model, model_a_old)
+
+ operation = AddField(
+ "c",
+ "to_a",
+ models.OneToOneField(
+ "something.A",
+ models.CASCADE,
+ related_name="from_c",
+ ),
+ )
+ operation.state_forwards("something", project_state)
+ model_a_new = project_state.apps.get_model("something", "A")
+ model_b_new = project_state.apps.get_model("something", "B")
+ model_c_new = project_state.apps.get_model("something", "C")
+
+ # All models have changed
+ self.assertIsNot(model_a_old, model_a_new)
+ self.assertIsNot(model_b_old, model_b_new)
+ self.assertIsNot(model_c_old, model_c_new)
+ # The relations between the old models still hold
+ self.assertIs(model_a_old._meta.get_field("b").related_model, model_b_old)
+ self.assertIs(model_b_old._meta.get_field("a_ptr").related_model, model_a_old)
+ # The relations between the new models correct
+ self.assertIs(model_a_new._meta.get_field("b").related_model, model_b_new)
+ self.assertIs(model_b_new._meta.get_field("a_ptr").related_model, model_a_new)
+ self.assertIs(model_a_new._meta.get_field("from_c").related_model, model_c_new)
+ self.assertIs(model_c_new._meta.get_field("to_a").related_model, model_a_new)
+
+ def test_remove_relations(self):
+ """
+ #24225 - Relations between models are updated while
+ remaining the relations and references for models of an old state.
+ """
+ new_apps = Apps()
+
+ class A(models.Model):
+ class Meta:
+ app_label = "something"
+ apps = new_apps
+
+ class B(models.Model):
+ to_a = models.ForeignKey(A, models.CASCADE)
+
+ class Meta:
+ app_label = "something"
+ apps = new_apps
+
+ def get_model_a(state):
+ return [
+ mod for mod in state.apps.get_models() if mod._meta.model_name == "a"
+ ][0]
+
+ project_state = ProjectState()
+ project_state.add_model(ModelState.from_model(A))
+ project_state.add_model(ModelState.from_model(B))
+ self.assertEqual(len(get_model_a(project_state)._meta.related_objects), 1)
+ old_state = project_state.clone()
+
+ operation = RemoveField("b", "to_a")
+ operation.state_forwards("something", project_state)
+ # Model from old_state still has the relation
+ model_a_old = get_model_a(old_state)
+ model_a_new = get_model_a(project_state)
+ self.assertIsNot(model_a_old, model_a_new)
+ self.assertEqual(len(model_a_old._meta.related_objects), 1)
+ self.assertEqual(len(model_a_new._meta.related_objects), 0)
+
+ # Same test for deleted model
+ project_state = ProjectState()
+ project_state.add_model(ModelState.from_model(A))
+ project_state.add_model(ModelState.from_model(B))
+ old_state = project_state.clone()
+
+ operation = DeleteModel("b")
+ operation.state_forwards("something", project_state)
+ model_a_old = get_model_a(old_state)
+ model_a_new = get_model_a(project_state)
+ self.assertIsNot(model_a_old, model_a_new)
+ self.assertEqual(len(model_a_old._meta.related_objects), 1)
+ self.assertEqual(len(model_a_new._meta.related_objects), 0)
+
+ def test_self_relation(self):
+ """
+ #24513 - Modifying an object pointing to itself would cause it to be
+ rendered twice and thus breaking its related M2M through objects.
+ """
+
+ class A(models.Model):
+ to_a = models.ManyToManyField("something.A", symmetrical=False)
+
+ class Meta:
+ app_label = "something"
+
+ def get_model_a(state):
+ return [
+ mod for mod in state.apps.get_models() if mod._meta.model_name == "a"
+ ][0]
+
+ project_state = ProjectState()
+ project_state.add_model(ModelState.from_model(A))
+ self.assertEqual(len(get_model_a(project_state)._meta.related_objects), 1)
+ old_state = project_state.clone()
+
+ operation = AlterField(
+ model_name="a",
+ name="to_a",
+ field=models.ManyToManyField("something.A", symmetrical=False, blank=True),
+ )
+ # At this point the model would be rendered twice causing its related
+ # M2M through objects to point to an old copy and thus breaking their
+ # attribute lookup.
+ operation.state_forwards("something", project_state)
+
+ model_a_old = get_model_a(old_state)
+ model_a_new = get_model_a(project_state)
+ self.assertIsNot(model_a_old, model_a_new)
+
+ # The old model's _meta is still consistent
+ field_to_a_old = model_a_old._meta.get_field("to_a")
+ self.assertEqual(field_to_a_old.m2m_field_name(), "from_a")
+ self.assertEqual(field_to_a_old.m2m_reverse_field_name(), "to_a")
+ self.assertIs(field_to_a_old.related_model, model_a_old)
+ self.assertIs(
+ field_to_a_old.remote_field.through._meta.get_field("to_a").related_model,
+ model_a_old,
+ )
+ self.assertIs(
+ field_to_a_old.remote_field.through._meta.get_field("from_a").related_model,
+ model_a_old,
+ )
+
+ # The new model's _meta is still consistent
+ field_to_a_new = model_a_new._meta.get_field("to_a")
+ self.assertEqual(field_to_a_new.m2m_field_name(), "from_a")
+ self.assertEqual(field_to_a_new.m2m_reverse_field_name(), "to_a")
+ self.assertIs(field_to_a_new.related_model, model_a_new)
+ self.assertIs(
+ field_to_a_new.remote_field.through._meta.get_field("to_a").related_model,
+ model_a_new,
+ )
+ self.assertIs(
+ field_to_a_new.remote_field.through._meta.get_field("from_a").related_model,
+ model_a_new,
+ )
+
+ def test_equality(self):
+ """
+ == and != are implemented correctly.
+ """
+ # Test two things that should be equal
+ project_state = ProjectState()
+ project_state.add_model(
+ ModelState(
+ "migrations",
+ "Tag",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ("name", models.CharField(max_length=100)),
+ ("hidden", models.BooleanField()),
+ ],
+ {},
+ None,
+ )
+ )
+ project_state.apps # Fill the apps cached property
+ other_state = project_state.clone()
+ self.assertEqual(project_state, project_state)
+ self.assertEqual(project_state, other_state)
+ self.assertIs(project_state != project_state, False)
+ self.assertIs(project_state != other_state, False)
+ self.assertNotEqual(project_state.apps, other_state.apps)
+
+ # Make a very small change (max_len 99) and see if that affects it
+ project_state = ProjectState()
+ project_state.add_model(
+ ModelState(
+ "migrations",
+ "Tag",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ("name", models.CharField(max_length=99)),
+ ("hidden", models.BooleanField()),
+ ],
+ {},
+ None,
+ )
+ )
+ self.assertNotEqual(project_state, other_state)
+ self.assertIs(project_state == other_state, False)
+
+ def test_dangling_references_throw_error(self):
+ new_apps = Apps()
+
+ class Author(models.Model):
+ name = models.TextField()
+
+ class Meta:
+ app_label = "migrations"
+ apps = new_apps
+
+ class Publisher(models.Model):
+ name = models.TextField()
+
+ class Meta:
+ app_label = "migrations"
+ apps = new_apps
+
+ class Book(models.Model):
+ author = models.ForeignKey(Author, models.CASCADE)
+ publisher = models.ForeignKey(Publisher, models.CASCADE)
+
+ class Meta:
+ app_label = "migrations"
+ apps = new_apps
+
+ class Magazine(models.Model):
+ authors = models.ManyToManyField(Author)
+
+ class Meta:
+ app_label = "migrations"
+ apps = new_apps
+
+ # Make a valid ProjectState and render it
+ project_state = ProjectState()
+ project_state.add_model(ModelState.from_model(Author))
+ project_state.add_model(ModelState.from_model(Publisher))
+ project_state.add_model(ModelState.from_model(Book))
+ project_state.add_model(ModelState.from_model(Magazine))
+ self.assertEqual(len(project_state.apps.get_models()), 4)
+
+ # now make an invalid one with a ForeignKey
+ project_state = ProjectState()
+ project_state.add_model(ModelState.from_model(Book))
+ msg = (
+ "The field migrations.Book.author was declared with a lazy reference "
+ "to 'migrations.author', but app 'migrations' doesn't provide model "
+ "'author'.\n"
+ "The field migrations.Book.publisher was declared with a lazy reference "
+ "to 'migrations.publisher', but app 'migrations' doesn't provide model "
+ "'publisher'."
+ )
+ with self.assertRaisesMessage(ValueError, msg):
+ project_state.apps
+
+ # And another with ManyToManyField.
+ project_state = ProjectState()
+ project_state.add_model(ModelState.from_model(Magazine))
+ msg = (
+ "The field migrations.Magazine.authors was declared with a lazy reference "
+ "to 'migrations.author', but app 'migrations' doesn't provide model "
+ "'author'.\n"
+ "The field migrations.Magazine_authors.author was declared with a lazy "
+ "reference to 'migrations.author', but app 'migrations' doesn't provide "
+ "model 'author'."
+ )
+ with self.assertRaisesMessage(ValueError, msg):
+ project_state.apps
+
+ # And now with multiple models and multiple fields.
+ project_state.add_model(ModelState.from_model(Book))
+ msg = (
+ "The field migrations.Book.author was declared with a lazy reference "
+ "to 'migrations.author', but app 'migrations' doesn't provide model "
+ "'author'.\n"
+ "The field migrations.Book.publisher was declared with a lazy reference "
+ "to 'migrations.publisher', but app 'migrations' doesn't provide model "
+ "'publisher'.\n"
+ "The field migrations.Magazine.authors was declared with a lazy reference "
+ "to 'migrations.author', but app 'migrations' doesn't provide model "
+ "'author'.\n"
+ "The field migrations.Magazine_authors.author was declared with a lazy "
+ "reference to 'migrations.author', but app 'migrations' doesn't provide "
+ "model 'author'."
+ )
+ with self.assertRaisesMessage(ValueError, msg):
+ project_state.apps
+
+ def test_reference_mixed_case_app_label(self):
+ new_apps = Apps()
+
+ class Author(models.Model):
+ class Meta:
+ app_label = "MiXedCase_migrations"
+ apps = new_apps
+
+ class Book(models.Model):
+ author = models.ForeignKey(Author, models.CASCADE)
+
+ class Meta:
+ app_label = "MiXedCase_migrations"
+ apps = new_apps
+
+ class Magazine(models.Model):
+ authors = models.ManyToManyField(Author)
+
+ class Meta:
+ app_label = "MiXedCase_migrations"
+ apps = new_apps
+
+ project_state = ProjectState()
+ project_state.add_model(ModelState.from_model(Author))
+ project_state.add_model(ModelState.from_model(Book))
+ project_state.add_model(ModelState.from_model(Magazine))
+ self.assertEqual(len(project_state.apps.get_models()), 3)
+
+ def test_real_apps(self):
+ """
+ Including real apps can resolve dangling FK errors.
+ This test relies on the fact that contenttypes is always loaded.
+ """
+ new_apps = Apps()
+
+ class TestModel(models.Model):
+ ct = models.ForeignKey("contenttypes.ContentType", models.CASCADE)
+
+ class Meta:
+ app_label = "migrations"
+ apps = new_apps
+
+ # If we just stick it into an empty state it should fail
+ project_state = ProjectState()
+ project_state.add_model(ModelState.from_model(TestModel))
+ with self.assertRaises(ValueError):
+ project_state.apps
+
+ # If we include the real app it should succeed
+ project_state = ProjectState(real_apps={"contenttypes"})
+ project_state.add_model(ModelState.from_model(TestModel))
+ rendered_state = project_state.apps
+ self.assertEqual(
+ len(
+ [
+ x
+ for x in rendered_state.get_models()
+ if x._meta.app_label == "migrations"
+ ]
+ ),
+ 1,
+ )
+
+ def test_real_apps_non_set(self):
+ with self.assertRaises(AssertionError):
+ ProjectState(real_apps=["contenttypes"])
+
+ def test_ignore_order_wrt(self):
+ """
+ Makes sure ProjectState doesn't include OrderWrt fields when
+ making from existing models.
+ """
+ new_apps = Apps()
+
+ class Author(models.Model):
+ name = models.TextField()
+
+ class Meta:
+ app_label = "migrations"
+ apps = new_apps
+
+ class Book(models.Model):
+ author = models.ForeignKey(Author, models.CASCADE)
+
+ class Meta:
+ app_label = "migrations"
+ apps = new_apps
+ order_with_respect_to = "author"
+
+ # Make a valid ProjectState and render it
+ project_state = ProjectState()
+ project_state.add_model(ModelState.from_model(Author))
+ project_state.add_model(ModelState.from_model(Book))
+ self.assertEqual(
+ list(project_state.models["migrations", "book"].fields),
+ ["id", "author"],
+ )
+
+ def test_modelstate_get_field_order_wrt(self):
+ new_apps = Apps()
+
+ class Author(models.Model):
+ name = models.TextField()
+
+ class Meta:
+ app_label = "migrations"
+ apps = new_apps
+
+ class Book(models.Model):
+ author = models.ForeignKey(Author, models.CASCADE)
+
+ class Meta:
+ app_label = "migrations"
+ apps = new_apps
+ order_with_respect_to = "author"
+
+ model_state = ModelState.from_model(Book)
+ order_wrt_field = model_state.get_field("_order")
+ self.assertIsInstance(order_wrt_field, models.ForeignKey)
+ self.assertEqual(order_wrt_field.related_model, "migrations.author")
+
+ def test_modelstate_get_field_no_order_wrt_order_field(self):
+ new_apps = Apps()
+
+ class HistoricalRecord(models.Model):
+ _order = models.PositiveSmallIntegerField()
+
+ class Meta:
+ app_label = "migrations"
+ apps = new_apps
+
+ model_state = ModelState.from_model(HistoricalRecord)
+ order_field = model_state.get_field("_order")
+ self.assertIsNone(order_field.related_model)
+ self.assertIsInstance(order_field, models.PositiveSmallIntegerField)
+
+ def test_manager_refer_correct_model_version(self):
+ """
+ #24147 - Managers refer to the correct version of a
+ historical model
+ """
+ project_state = ProjectState()
+ project_state.add_model(
+ ModelState(
+ app_label="migrations",
+ name="Tag",
+ fields=[
+ ("id", models.AutoField(primary_key=True)),
+ ("hidden", models.BooleanField()),
+ ],
+ managers=[
+ ("food_mgr", FoodManager("a", "b")),
+ ("food_qs", FoodQuerySet.as_manager()),
+ ],
+ )
+ )
+
+ old_model = project_state.apps.get_model("migrations", "tag")
+
+ new_state = project_state.clone()
+ operation = RemoveField("tag", "hidden")
+ operation.state_forwards("migrations", new_state)
+
+ new_model = new_state.apps.get_model("migrations", "tag")
+
+ self.assertIsNot(old_model, new_model)
+ self.assertIs(old_model, old_model.food_mgr.model)
+ self.assertIs(old_model, old_model.food_qs.model)
+ self.assertIs(new_model, new_model.food_mgr.model)
+ self.assertIs(new_model, new_model.food_qs.model)
+ self.assertIsNot(old_model.food_mgr, new_model.food_mgr)
+ self.assertIsNot(old_model.food_qs, new_model.food_qs)
+ self.assertIsNot(old_model.food_mgr.model, new_model.food_mgr.model)
+ self.assertIsNot(old_model.food_qs.model, new_model.food_qs.model)
+
+ def test_choices_iterator(self):
+ """
+ #24483 - ProjectState.from_apps should not destructively consume
+ Field.choices iterators.
+ """
+ new_apps = Apps(["migrations"])
+ choices = [("a", "A"), ("b", "B")]
+
+ class Author(models.Model):
+ name = models.CharField(max_length=255)
+ choice = models.CharField(max_length=255, choices=iter(choices))
+
+ class Meta:
+ app_label = "migrations"
+ apps = new_apps
+
+ ProjectState.from_apps(new_apps)
+ choices_field = Author._meta.get_field("choice")
+ self.assertEqual(list(choices_field.choices), choices)
+
+
+class StateRelationsTests(SimpleTestCase):
+ def get_base_project_state(self):
+ new_apps = Apps()
+
+ class User(models.Model):
+ class Meta:
+ app_label = "tests"
+ apps = new_apps
+
+ class Comment(models.Model):
+ text = models.TextField()
+ user = models.ForeignKey(User, models.CASCADE)
+ comments = models.ManyToManyField("self")
+
+ class Meta:
+ app_label = "tests"
+ apps = new_apps
+
+ class Post(models.Model):
+ text = models.TextField()
+ authors = models.ManyToManyField(User)
+
+ class Meta:
+ app_label = "tests"
+ apps = new_apps
+
+ project_state = ProjectState()
+ project_state.add_model(ModelState.from_model(User))
+ project_state.add_model(ModelState.from_model(Comment))
+ project_state.add_model(ModelState.from_model(Post))
+ return project_state
+
+ def test_relations_population(self):
+ tests = [
+ (
+ "add_model",
+ [
+ ModelState(
+ app_label="migrations",
+ name="Tag",
+ fields=[("id", models.AutoField(primary_key=True))],
+ ),
+ ],
+ ),
+ ("remove_model", ["tests", "comment"]),
+ ("rename_model", ["tests", "comment", "opinion"]),
+ (
+ "add_field",
+ [
+ "tests",
+ "post",
+ "next_post",
+ models.ForeignKey("self", models.CASCADE),
+ True,
+ ],
+ ),
+ ("remove_field", ["tests", "post", "text"]),
+ ("rename_field", ["tests", "comment", "user", "author"]),
+ (
+ "alter_field",
+ [
+ "tests",
+ "comment",
+ "user",
+ models.IntegerField(),
+ True,
+ ],
+ ),
+ ]
+ for method, args in tests:
+ with self.subTest(method=method):
+ project_state = self.get_base_project_state()
+ getattr(project_state, method)(*args)
+ # ProjectState's `_relations` are populated on `relations` access.
+ self.assertIsNone(project_state._relations)
+ self.assertEqual(project_state.relations, project_state._relations)
+ self.assertIsNotNone(project_state._relations)
+
+ def test_add_model(self):
+ project_state = self.get_base_project_state()
+ self.assertEqual(
+ list(project_state.relations["tests", "user"]),
+ [("tests", "comment"), ("tests", "post")],
+ )
+ self.assertEqual(
+ list(project_state.relations["tests", "comment"]),
+ [("tests", "comment")],
+ )
+ self.assertNotIn(("tests", "post"), project_state.relations)
+
+ def test_add_model_no_relations(self):
+ project_state = ProjectState()
+ project_state.add_model(
+ ModelState(
+ app_label="migrations",
+ name="Tag",
+ fields=[("id", models.AutoField(primary_key=True))],
+ )
+ )
+ self.assertEqual(project_state.relations, {})
+
+ def test_add_model_other_app(self):
+ project_state = self.get_base_project_state()
+ self.assertEqual(
+ list(project_state.relations["tests", "user"]),
+ [("tests", "comment"), ("tests", "post")],
+ )
+ project_state.add_model(
+ ModelState(
+ app_label="tests_other",
+ name="comment",
+ fields=[
+ ("id", models.AutoField(primary_key=True)),
+ ("user", models.ForeignKey("tests.user", models.CASCADE)),
+ ],
+ )
+ )
+ self.assertEqual(
+ list(project_state.relations["tests", "user"]),
+ [("tests", "comment"), ("tests", "post"), ("tests_other", "comment")],
+ )
+
+ def test_remove_model(self):
+ project_state = self.get_base_project_state()
+ self.assertEqual(
+ list(project_state.relations["tests", "user"]),
+ [("tests", "comment"), ("tests", "post")],
+ )
+ self.assertEqual(
+ list(project_state.relations["tests", "comment"]),
+ [("tests", "comment")],
+ )
+
+ project_state.remove_model("tests", "comment")
+ self.assertEqual(
+ list(project_state.relations["tests", "user"]),
+ [("tests", "post")],
+ )
+ self.assertNotIn(("tests", "comment"), project_state.relations)
+ project_state.remove_model("tests", "post")
+ self.assertEqual(project_state.relations, {})
+ project_state.remove_model("tests", "user")
+ self.assertEqual(project_state.relations, {})
+
+ def test_rename_model(self):
+ project_state = self.get_base_project_state()
+ self.assertEqual(
+ list(project_state.relations["tests", "user"]),
+ [("tests", "comment"), ("tests", "post")],
+ )
+ self.assertEqual(
+ list(project_state.relations["tests", "comment"]),
+ [("tests", "comment")],
+ )
+
+ related_field = project_state.relations["tests", "user"]["tests", "comment"]
+ project_state.rename_model("tests", "comment", "opinion")
+ self.assertEqual(
+ list(project_state.relations["tests", "user"]),
+ [("tests", "post"), ("tests", "opinion")],
+ )
+ self.assertEqual(
+ list(project_state.relations["tests", "opinion"]),
+ [("tests", "opinion")],
+ )
+ self.assertNotIn(("tests", "comment"), project_state.relations)
+ self.assertEqual(
+ project_state.relations["tests", "user"]["tests", "opinion"],
+ related_field,
+ )
+
+ project_state.rename_model("tests", "user", "author")
+ self.assertEqual(
+ list(project_state.relations["tests", "author"]),
+ [("tests", "post"), ("tests", "opinion")],
+ )
+ self.assertNotIn(("tests", "user"), project_state.relations)
+
+ def test_rename_model_no_relations(self):
+ project_state = self.get_base_project_state()
+ self.assertEqual(
+ list(project_state.relations["tests", "user"]),
+ [("tests", "comment"), ("tests", "post")],
+ )
+ related_field = project_state.relations["tests", "user"]["tests", "post"]
+ self.assertNotIn(("tests", "post"), project_state.relations)
+ # Rename a model without relations.
+ project_state.rename_model("tests", "post", "blog")
+ self.assertEqual(
+ list(project_state.relations["tests", "user"]),
+ [("tests", "comment"), ("tests", "blog")],
+ )
+ self.assertNotIn(("tests", "blog"), project_state.relations)
+ self.assertEqual(
+ related_field,
+ project_state.relations["tests", "user"]["tests", "blog"],
+ )
+
+ def test_add_field(self):
+ project_state = self.get_base_project_state()
+ self.assertNotIn(("tests", "post"), project_state.relations)
+ # Add a self-referential foreign key.
+ new_field = models.ForeignKey("self", models.CASCADE)
+ project_state.add_field(
+ "tests",
+ "post",
+ "next_post",
+ new_field,
+ preserve_default=True,
+ )
+ self.assertEqual(
+ list(project_state.relations["tests", "post"]),
+ [("tests", "post")],
+ )
+ self.assertEqual(
+ project_state.relations["tests", "post"]["tests", "post"],
+ {"next_post": new_field},
+ )
+ # Add a foreign key.
+ new_field = models.ForeignKey("tests.post", models.CASCADE)
+ project_state.add_field(
+ "tests",
+ "comment",
+ "post",
+ new_field,
+ preserve_default=True,
+ )
+ self.assertEqual(
+ list(project_state.relations["tests", "post"]),
+ [("tests", "post"), ("tests", "comment")],
+ )
+ self.assertEqual(
+ project_state.relations["tests", "post"]["tests", "comment"],
+ {"post": new_field},
+ )
+
+ def test_add_field_m2m_with_through(self):
+ project_state = self.get_base_project_state()
+ project_state.add_model(
+ ModelState(
+ app_label="tests",
+ name="Tag",
+ fields=[("id", models.AutoField(primary_key=True))],
+ )
+ )
+ project_state.add_model(
+ ModelState(
+ app_label="tests",
+ name="PostTag",
+ fields=[
+ ("id", models.AutoField(primary_key=True)),
+ ("post", models.ForeignKey("tests.post", models.CASCADE)),
+ ("tag", models.ForeignKey("tests.tag", models.CASCADE)),
+ ],
+ )
+ )
+ self.assertEqual(
+ list(project_state.relations["tests", "post"]),
+ [("tests", "posttag")],
+ )
+ self.assertEqual(
+ list(project_state.relations["tests", "tag"]),
+ [("tests", "posttag")],
+ )
+ # Add a many-to-many field with the through model.
+ new_field = models.ManyToManyField("tests.tag", through="tests.posttag")
+ project_state.add_field(
+ "tests",
+ "post",
+ "tags",
+ new_field,
+ preserve_default=True,
+ )
+ self.assertEqual(
+ list(project_state.relations["tests", "post"]),
+ [("tests", "posttag")],
+ )
+ self.assertEqual(
+ list(project_state.relations["tests", "tag"]),
+ [("tests", "posttag"), ("tests", "post")],
+ )
+ self.assertEqual(
+ project_state.relations["tests", "tag"]["tests", "post"],
+ {"tags": new_field},
+ )
+
+ def test_remove_field(self):
+ project_state = self.get_base_project_state()
+ self.assertEqual(
+ list(project_state.relations["tests", "user"]),
+ [("tests", "comment"), ("tests", "post")],
+ )
+ # Remove a many-to-many field.
+ project_state.remove_field("tests", "post", "authors")
+ self.assertEqual(
+ list(project_state.relations["tests", "user"]),
+ [("tests", "comment")],
+ )
+ # Remove a foreign key.
+ project_state.remove_field("tests", "comment", "user")
+ self.assertEqual(project_state.relations["tests", "user"], {})
+
+ def test_remove_field_no_relations(self):
+ project_state = self.get_base_project_state()
+ self.assertEqual(
+ list(project_state.relations["tests", "user"]),
+ [("tests", "comment"), ("tests", "post")],
+ )
+ # Remove a non-relation field.
+ project_state.remove_field("tests", "post", "text")
+ self.assertEqual(
+ list(project_state.relations["tests", "user"]),
+ [("tests", "comment"), ("tests", "post")],
+ )
+
+ def test_rename_field(self):
+ project_state = self.get_base_project_state()
+ field = project_state.models["tests", "comment"].fields["user"]
+ self.assertEqual(
+ project_state.relations["tests", "user"]["tests", "comment"],
+ {"user": field},
+ )
+
+ project_state.rename_field("tests", "comment", "user", "author")
+ renamed_field = project_state.models["tests", "comment"].fields["author"]
+ self.assertEqual(
+ project_state.relations["tests", "user"]["tests", "comment"],
+ {"author": renamed_field},
+ )
+ self.assertEqual(field, renamed_field)
+
+ def test_rename_field_no_relations(self):
+ project_state = self.get_base_project_state()
+ self.assertEqual(
+ list(project_state.relations["tests", "user"]),
+ [("tests", "comment"), ("tests", "post")],
+ )
+ # Rename a non-relation field.
+ project_state.rename_field("tests", "post", "text", "description")
+ self.assertEqual(
+ list(project_state.relations["tests", "user"]),
+ [("tests", "comment"), ("tests", "post")],
+ )
+
+ def test_alter_field(self):
+ project_state = self.get_base_project_state()
+ self.assertEqual(
+ list(project_state.relations["tests", "user"]),
+ [("tests", "comment"), ("tests", "post")],
+ )
+ # Alter a foreign key to a non-relation field.
+ project_state.alter_field(
+ "tests",
+ "comment",
+ "user",
+ models.IntegerField(),
+ preserve_default=True,
+ )
+ self.assertEqual(
+ list(project_state.relations["tests", "user"]),
+ [("tests", "post")],
+ )
+ # Alter a non-relation field to a many-to-many field.
+ m2m_field = models.ManyToManyField("tests.user")
+ project_state.alter_field(
+ "tests",
+ "comment",
+ "user",
+ m2m_field,
+ preserve_default=True,
+ )
+ self.assertEqual(
+ list(project_state.relations["tests", "user"]),
+ [("tests", "post"), ("tests", "comment")],
+ )
+ self.assertEqual(
+ project_state.relations["tests", "user"]["tests", "comment"],
+ {"user": m2m_field},
+ )
+
+ def test_alter_field_m2m_to_fk(self):
+ project_state = self.get_base_project_state()
+ project_state.add_model(
+ ModelState(
+ app_label="tests_other",
+ name="user_other",
+ fields=[("id", models.AutoField(primary_key=True))],
+ )
+ )
+ self.assertEqual(
+ list(project_state.relations["tests", "user"]),
+ [("tests", "comment"), ("tests", "post")],
+ )
+ self.assertNotIn(("tests_other", "user_other"), project_state.relations)
+ # Alter a many-to-many field to a foreign key.
+ foreign_key = models.ForeignKey("tests_other.user_other", models.CASCADE)
+ project_state.alter_field(
+ "tests",
+ "post",
+ "authors",
+ foreign_key,
+ preserve_default=True,
+ )
+ self.assertEqual(
+ list(project_state.relations["tests", "user"]),
+ [("tests", "comment")],
+ )
+ self.assertEqual(
+ list(project_state.relations["tests_other", "user_other"]),
+ [("tests", "post")],
+ )
+ self.assertEqual(
+ project_state.relations["tests_other", "user_other"]["tests", "post"],
+ {"authors": foreign_key},
+ )
+
+ def test_many_relations_to_same_model(self):
+ project_state = self.get_base_project_state()
+ new_field = models.ForeignKey("tests.user", models.CASCADE)
+ project_state.add_field(
+ "tests",
+ "comment",
+ "reviewer",
+ new_field,
+ preserve_default=True,
+ )
+ self.assertEqual(
+ list(project_state.relations["tests", "user"]),
+ [("tests", "comment"), ("tests", "post")],
+ )
+ comment_rels = project_state.relations["tests", "user"]["tests", "comment"]
+ # Two foreign keys to the same model.
+ self.assertEqual(len(comment_rels), 2)
+ self.assertEqual(comment_rels["reviewer"], new_field)
+ # Rename the second foreign key.
+ project_state.rename_field("tests", "comment", "reviewer", "supervisor")
+ self.assertEqual(len(comment_rels), 2)
+ self.assertEqual(comment_rels["supervisor"], new_field)
+ # Remove the first foreign key.
+ project_state.remove_field("tests", "comment", "user")
+ self.assertEqual(comment_rels, {"supervisor": new_field})
+
+
+class ModelStateTests(SimpleTestCase):
+ def test_custom_model_base(self):
+ state = ModelState.from_model(ModelWithCustomBase)
+ self.assertEqual(state.bases, (models.Model,))
+
+ def test_bound_field_sanity_check(self):
+ field = models.CharField(max_length=1)
+ field.model = models.Model
+ with self.assertRaisesMessage(
+ ValueError, 'ModelState.fields cannot be bound to a model - "field" is.'
+ ):
+ ModelState("app", "Model", [("field", field)])
+
+ def test_sanity_check_to(self):
+ field = models.ForeignKey(UnicodeModel, models.CASCADE)
+ with self.assertRaisesMessage(
+ ValueError,
+ 'ModelState.fields cannot refer to a model class - "field.to" does. '
+ "Use a string reference instead.",
+ ):
+ ModelState("app", "Model", [("field", field)])
+
+ def test_sanity_check_through(self):
+ field = models.ManyToManyField("UnicodeModel")
+ field.remote_field.through = UnicodeModel
+ with self.assertRaisesMessage(
+ ValueError,
+ 'ModelState.fields cannot refer to a model class - "field.through" does. '
+ "Use a string reference instead.",
+ ):
+ ModelState("app", "Model", [("field", field)])
+
+ def test_sanity_index_name(self):
+ field = models.IntegerField()
+ options = {"indexes": [models.Index(fields=["field"])]}
+ msg = (
+ "Indexes passed to ModelState require a name attribute. doesn't have one."
+ )
+ with self.assertRaisesMessage(ValueError, msg):
+ ModelState("app", "Model", [("field", field)], options=options)
+
+ def test_fields_immutability(self):
+ """
+ Rendering a model state doesn't alter its internal fields.
+ """
+ apps = Apps()
+ field = models.CharField(max_length=1)
+ state = ModelState("app", "Model", [("name", field)])
+ Model = state.render(apps)
+ self.assertNotEqual(Model._meta.get_field("name"), field)
+
+ def test_repr(self):
+ field = models.CharField(max_length=1)
+ state = ModelState(
+ "app", "Model", [("name", field)], bases=["app.A", "app.B", "app.C"]
+ )
+ self.assertEqual(repr(state), "")
+
+ project_state = ProjectState()
+ project_state.add_model(state)
+ with self.assertRaisesMessage(
+ InvalidBasesError, "Cannot resolve bases for []"
+ ):
+ project_state.apps
+
+ def test_fields_ordering_equality(self):
+ state = ModelState(
+ "migrations",
+ "Tag",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ("name", models.CharField(max_length=100)),
+ ("hidden", models.BooleanField()),
+ ],
+ )
+ reordered_state = ModelState(
+ "migrations",
+ "Tag",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ # Purposely re-ordered.
+ ("hidden", models.BooleanField()),
+ ("name", models.CharField(max_length=100)),
+ ],
+ )
+ self.assertEqual(state, reordered_state)
+
+ @override_settings(TEST_SWAPPABLE_MODEL="migrations.SomeFakeModel")
+ def test_create_swappable(self):
+ """
+ Tests making a ProjectState from an Apps with a swappable model
+ """
+ new_apps = Apps(["migrations"])
+
+ class Author(models.Model):
+ name = models.CharField(max_length=255)
+ bio = models.TextField()
+ age = models.IntegerField(blank=True, null=True)
+
+ class Meta:
+ app_label = "migrations"
+ apps = new_apps
+ swappable = "TEST_SWAPPABLE_MODEL"
+
+ author_state = ModelState.from_model(Author)
+ self.assertEqual(author_state.app_label, "migrations")
+ self.assertEqual(author_state.name, "Author")
+ self.assertEqual(list(author_state.fields), ["id", "name", "bio", "age"])
+ self.assertEqual(author_state.fields["name"].max_length, 255)
+ self.assertIs(author_state.fields["bio"].null, False)
+ self.assertIs(author_state.fields["age"].null, True)
+ self.assertEqual(
+ author_state.options,
+ {"swappable": "TEST_SWAPPABLE_MODEL", "indexes": [], "constraints": []},
+ )
+ self.assertEqual(author_state.bases, (models.Model,))
+ self.assertEqual(author_state.managers, [])
+
+ @override_settings(TEST_SWAPPABLE_MODEL="migrations.SomeFakeModel")
+ def test_create_swappable_from_abstract(self):
+ """
+ A swappable model inheriting from a hierarchy:
+ concrete -> abstract -> concrete.
+ """
+ new_apps = Apps(["migrations"])
+
+ class SearchableLocation(models.Model):
+ keywords = models.CharField(max_length=256)
+
+ class Meta:
+ app_label = "migrations"
+ apps = new_apps
+
+ class Station(SearchableLocation):
+ name = models.CharField(max_length=128)
+
+ class Meta:
+ abstract = True
+
+ class BusStation(Station):
+ bus_routes = models.CharField(max_length=128)
+ inbound = models.BooleanField(default=False)
+
+ class Meta(Station.Meta):
+ app_label = "migrations"
+ apps = new_apps
+ swappable = "TEST_SWAPPABLE_MODEL"
+
+ station_state = ModelState.from_model(BusStation)
+ self.assertEqual(station_state.app_label, "migrations")
+ self.assertEqual(station_state.name, "BusStation")
+ self.assertEqual(
+ list(station_state.fields),
+ ["searchablelocation_ptr", "name", "bus_routes", "inbound"],
+ )
+ self.assertEqual(station_state.fields["name"].max_length, 128)
+ self.assertIs(station_state.fields["bus_routes"].null, False)
+ self.assertEqual(
+ station_state.options,
+ {
+ "abstract": False,
+ "swappable": "TEST_SWAPPABLE_MODEL",
+ "indexes": [],
+ "constraints": [],
+ },
+ )
+ self.assertEqual(station_state.bases, ("migrations.searchablelocation",))
+ self.assertEqual(station_state.managers, [])
+
+ @override_settings(TEST_SWAPPABLE_MODEL="migrations.SomeFakeModel")
+ def test_custom_manager_swappable(self):
+ """
+ Tests making a ProjectState from unused models with custom managers
+ """
+ new_apps = Apps(["migrations"])
+
+ class Food(models.Model):
+ food_mgr = FoodManager("a", "b")
+ food_qs = FoodQuerySet.as_manager()
+ food_no_mgr = NoMigrationFoodManager("x", "y")
+
+ class Meta:
+ app_label = "migrations"
+ apps = new_apps
+ swappable = "TEST_SWAPPABLE_MODEL"
+
+ food_state = ModelState.from_model(Food)
+
+ # The default manager is used in migrations
+ self.assertEqual([name for name, mgr in food_state.managers], ["food_mgr"])
+ self.assertEqual(food_state.managers[0][1].args, ("a", "b", 1, 2))
+
+ @isolate_apps("migrations", "django.contrib.contenttypes")
+ def test_order_with_respect_to_private_field(self):
+ class PrivateFieldModel(models.Model):
+ content_type = models.ForeignKey("contenttypes.ContentType", models.CASCADE)
+ object_id = models.PositiveIntegerField()
+ private = GenericForeignKey()
+
+ class Meta:
+ order_with_respect_to = "private"
+
+ state = ModelState.from_model(PrivateFieldModel)
+ self.assertNotIn("order_with_respect_to", state.options)
+
+ @isolate_apps("migrations")
+ def test_abstract_model_children_inherit_indexes(self):
+ class Abstract(models.Model):
+ name = models.CharField(max_length=50)
+
+ class Meta:
+ app_label = "migrations"
+ abstract = True
+ indexes = [models.Index(fields=["name"])]
+
+ class Child1(Abstract):
+ pass
+
+ class Child2(Abstract):
+ pass
+
+ child1_state = ModelState.from_model(Child1)
+ child2_state = ModelState.from_model(Child2)
+ index_names = [index.name for index in child1_state.options["indexes"]]
+ self.assertEqual(index_names, ["migrations__name_b0afd7_idx"])
+ index_names = [index.name for index in child2_state.options["indexes"]]
+ self.assertEqual(index_names, ["migrations__name_016466_idx"])
+
+ # Modifying the state doesn't modify the index on the model.
+ child1_state.options["indexes"][0].name = "bar"
+ self.assertEqual(Child1._meta.indexes[0].name, "migrations__name_b0afd7_idx")
+
+ @isolate_apps("migrations")
+ def test_explicit_index_name(self):
+ class TestModel(models.Model):
+ name = models.CharField(max_length=50)
+
+ class Meta:
+ app_label = "migrations"
+ indexes = [models.Index(fields=["name"], name="foo_idx")]
+
+ model_state = ModelState.from_model(TestModel)
+ index_names = [index.name for index in model_state.options["indexes"]]
+ self.assertEqual(index_names, ["foo_idx"])
+
+ @isolate_apps("migrations")
+ def test_from_model_constraints(self):
+ class ModelWithConstraints(models.Model):
+ size = models.IntegerField()
+
+ class Meta:
+ constraints = [
+ models.CheckConstraint(check=models.Q(size__gt=1), name="size_gt_1")
+ ]
+
+ state = ModelState.from_model(ModelWithConstraints)
+ model_constraints = ModelWithConstraints._meta.constraints
+ state_constraints = state.options["constraints"]
+ self.assertEqual(model_constraints, state_constraints)
+ self.assertIsNot(model_constraints, state_constraints)
+ self.assertIsNot(model_constraints[0], state_constraints[0])
+
+
+class RelatedModelsTests(SimpleTestCase):
+ def setUp(self):
+ self.apps = Apps(["migrations.related_models_app"])
+
+ def create_model(
+ self, name, foreign_keys=[], bases=(), abstract=False, proxy=False
+ ):
+ test_name = "related_models_app"
+ assert not (abstract and proxy)
+ meta_contents = {
+ "abstract": abstract,
+ "app_label": test_name,
+ "apps": self.apps,
+ "proxy": proxy,
+ }
+ meta = type("Meta", (), meta_contents)
+ if not bases:
+ bases = (models.Model,)
+ body = {
+ "Meta": meta,
+ "__module__": "__fake__",
+ }
+ fname_base = fname = "%s_%%d" % name.lower()
+ for i, fk in enumerate(foreign_keys, 1):
+ fname = fname_base % i
+ body[fname] = fk
+ return type(name, bases, body)
+
+ def assertRelated(self, model, needle):
+ self.assertEqual(
+ get_related_models_recursive(model),
+ {(n._meta.app_label, n._meta.model_name) for n in needle},
+ )
+
+ def test_unrelated(self):
+ A = self.create_model("A")
+ B = self.create_model("B")
+ self.assertRelated(A, [])
+ self.assertRelated(B, [])
+
+ def test_direct_fk(self):
+ A = self.create_model(
+ "A", foreign_keys=[models.ForeignKey("B", models.CASCADE)]
+ )
+ B = self.create_model("B")
+ self.assertRelated(A, [B])
+ self.assertRelated(B, [A])
+
+ def test_direct_hidden_fk(self):
+ A = self.create_model(
+ "A", foreign_keys=[models.ForeignKey("B", models.CASCADE, related_name="+")]
+ )
+ B = self.create_model("B")
+ self.assertRelated(A, [B])
+ self.assertRelated(B, [A])
+
+ def test_fk_through_proxy(self):
+ A = self.create_model("A")
+ B = self.create_model("B", bases=(A,), proxy=True)
+ C = self.create_model("C", bases=(B,), proxy=True)
+ D = self.create_model(
+ "D", foreign_keys=[models.ForeignKey("C", models.CASCADE)]
+ )
+ self.assertRelated(A, [B, C, D])
+ self.assertRelated(B, [A, C, D])
+ self.assertRelated(C, [A, B, D])
+ self.assertRelated(D, [A, B, C])
+
+ def test_nested_fk(self):
+ A = self.create_model(
+ "A", foreign_keys=[models.ForeignKey("B", models.CASCADE)]
+ )
+ B = self.create_model(
+ "B", foreign_keys=[models.ForeignKey("C", models.CASCADE)]
+ )
+ C = self.create_model("C")
+ self.assertRelated(A, [B, C])
+ self.assertRelated(B, [A, C])
+ self.assertRelated(C, [A, B])
+
+ def test_two_sided(self):
+ A = self.create_model(
+ "A", foreign_keys=[models.ForeignKey("B", models.CASCADE)]
+ )
+ B = self.create_model(
+ "B", foreign_keys=[models.ForeignKey("A", models.CASCADE)]
+ )
+ self.assertRelated(A, [B])
+ self.assertRelated(B, [A])
+
+ def test_circle(self):
+ A = self.create_model(
+ "A", foreign_keys=[models.ForeignKey("B", models.CASCADE)]
+ )
+ B = self.create_model(
+ "B", foreign_keys=[models.ForeignKey("C", models.CASCADE)]
+ )
+ C = self.create_model(
+ "C", foreign_keys=[models.ForeignKey("A", models.CASCADE)]
+ )
+ self.assertRelated(A, [B, C])
+ self.assertRelated(B, [A, C])
+ self.assertRelated(C, [A, B])
+
+ def test_base(self):
+ A = self.create_model("A")
+ B = self.create_model("B", bases=(A,))
+ self.assertRelated(A, [B])
+ self.assertRelated(B, [A])
+
+ def test_nested_base(self):
+ A = self.create_model("A")
+ B = self.create_model("B", bases=(A,))
+ C = self.create_model("C", bases=(B,))
+ self.assertRelated(A, [B, C])
+ self.assertRelated(B, [A, C])
+ self.assertRelated(C, [A, B])
+
+ def test_multiple_bases(self):
+ A = self.create_model("A")
+ B = self.create_model("B")
+ C = self.create_model(
+ "C",
+ bases=(
+ A,
+ B,
+ ),
+ )
+ self.assertRelated(A, [B, C])
+ self.assertRelated(B, [A, C])
+ self.assertRelated(C, [A, B])
+
+ def test_multiple_nested_bases(self):
+ A = self.create_model("A")
+ B = self.create_model("B")
+ C = self.create_model(
+ "C",
+ bases=(
+ A,
+ B,
+ ),
+ )
+ D = self.create_model("D")
+ E = self.create_model("E", bases=(D,))
+ F = self.create_model(
+ "F",
+ bases=(
+ C,
+ E,
+ ),
+ )
+ Y = self.create_model("Y")
+ Z = self.create_model("Z", bases=(Y,))
+ self.assertRelated(A, [B, C, D, E, F])
+ self.assertRelated(B, [A, C, D, E, F])
+ self.assertRelated(C, [A, B, D, E, F])
+ self.assertRelated(D, [A, B, C, E, F])
+ self.assertRelated(E, [A, B, C, D, F])
+ self.assertRelated(F, [A, B, C, D, E])
+ self.assertRelated(Y, [Z])
+ self.assertRelated(Z, [Y])
+
+ def test_base_to_base_fk(self):
+ A = self.create_model(
+ "A", foreign_keys=[models.ForeignKey("Y", models.CASCADE)]
+ )
+ B = self.create_model("B", bases=(A,))
+ Y = self.create_model("Y")
+ Z = self.create_model("Z", bases=(Y,))
+ self.assertRelated(A, [B, Y, Z])
+ self.assertRelated(B, [A, Y, Z])
+ self.assertRelated(Y, [A, B, Z])
+ self.assertRelated(Z, [A, B, Y])
+
+ def test_base_to_subclass_fk(self):
+ A = self.create_model(
+ "A", foreign_keys=[models.ForeignKey("Z", models.CASCADE)]
+ )
+ B = self.create_model("B", bases=(A,))
+ Y = self.create_model("Y")
+ Z = self.create_model("Z", bases=(Y,))
+ self.assertRelated(A, [B, Y, Z])
+ self.assertRelated(B, [A, Y, Z])
+ self.assertRelated(Y, [A, B, Z])
+ self.assertRelated(Z, [A, B, Y])
+
+ def test_direct_m2m(self):
+ A = self.create_model("A", foreign_keys=[models.ManyToManyField("B")])
+ B = self.create_model("B")
+ self.assertRelated(A, [A.a_1.rel.through, B])
+ self.assertRelated(B, [A, A.a_1.rel.through])
+
+ def test_direct_m2m_self(self):
+ A = self.create_model("A", foreign_keys=[models.ManyToManyField("A")])
+ self.assertRelated(A, [A.a_1.rel.through])
+
+ def test_intermediate_m2m_self(self):
+ A = self.create_model(
+ "A", foreign_keys=[models.ManyToManyField("A", through="T")]
+ )
+ T = self.create_model(
+ "T",
+ foreign_keys=[
+ models.ForeignKey("A", models.CASCADE),
+ models.ForeignKey("A", models.CASCADE),
+ ],
+ )
+ self.assertRelated(A, [T])
+ self.assertRelated(T, [A])
+
+ def test_intermediate_m2m(self):
+ A = self.create_model(
+ "A", foreign_keys=[models.ManyToManyField("B", through="T")]
+ )
+ B = self.create_model("B")
+ T = self.create_model(
+ "T",
+ foreign_keys=[
+ models.ForeignKey("A", models.CASCADE),
+ models.ForeignKey("B", models.CASCADE),
+ ],
+ )
+ self.assertRelated(A, [B, T])
+ self.assertRelated(B, [A, T])
+ self.assertRelated(T, [A, B])
+
+ def test_intermediate_m2m_extern_fk(self):
+ A = self.create_model(
+ "A", foreign_keys=[models.ManyToManyField("B", through="T")]
+ )
+ B = self.create_model("B")
+ Z = self.create_model("Z")
+ T = self.create_model(
+ "T",
+ foreign_keys=[
+ models.ForeignKey("A", models.CASCADE),
+ models.ForeignKey("B", models.CASCADE),
+ models.ForeignKey("Z", models.CASCADE),
+ ],
+ )
+ self.assertRelated(A, [B, T, Z])
+ self.assertRelated(B, [A, T, Z])
+ self.assertRelated(T, [A, B, Z])
+ self.assertRelated(Z, [A, B, T])
+
+ def test_intermediate_m2m_base(self):
+ A = self.create_model(
+ "A", foreign_keys=[models.ManyToManyField("B", through="T")]
+ )
+ B = self.create_model("B")
+ S = self.create_model("S")
+ T = self.create_model(
+ "T",
+ foreign_keys=[
+ models.ForeignKey("A", models.CASCADE),
+ models.ForeignKey("B", models.CASCADE),
+ ],
+ bases=(S,),
+ )
+ self.assertRelated(A, [B, S, T])
+ self.assertRelated(B, [A, S, T])
+ self.assertRelated(S, [A, B, T])
+ self.assertRelated(T, [A, B, S])
+
+ def test_generic_fk(self):
+ A = self.create_model(
+ "A",
+ foreign_keys=[
+ models.ForeignKey("B", models.CASCADE),
+ GenericForeignKey(),
+ ],
+ )
+ B = self.create_model(
+ "B",
+ foreign_keys=[
+ models.ForeignKey("C", models.CASCADE),
+ ],
+ )
+ self.assertRelated(A, [B])
+ self.assertRelated(B, [A])
+
+ def test_abstract_base(self):
+ A = self.create_model("A", abstract=True)
+ B = self.create_model("B", bases=(A,))
+ self.assertRelated(A, [B])
+ self.assertRelated(B, [])
+
+ def test_nested_abstract_base(self):
+ A = self.create_model("A", abstract=True)
+ B = self.create_model("B", bases=(A,), abstract=True)
+ C = self.create_model("C", bases=(B,))
+ self.assertRelated(A, [B, C])
+ self.assertRelated(B, [C])
+ self.assertRelated(C, [])
+
+ def test_proxy_base(self):
+ A = self.create_model("A")
+ B = self.create_model("B", bases=(A,), proxy=True)
+ self.assertRelated(A, [B])
+ self.assertRelated(B, [])
+
+ def test_nested_proxy_base(self):
+ A = self.create_model("A")
+ B = self.create_model("B", bases=(A,), proxy=True)
+ C = self.create_model("C", bases=(B,), proxy=True)
+ self.assertRelated(A, [B, C])
+ self.assertRelated(B, [C])
+ self.assertRelated(C, [])
+
+ def test_multiple_mixed_bases(self):
+ A = self.create_model("A", abstract=True)
+ M = self.create_model("M")
+ P = self.create_model("P")
+ Q = self.create_model("Q", bases=(P,), proxy=True)
+ Z = self.create_model("Z", bases=(A, M, Q))
+ # M has a pointer O2O field p_ptr to P
+ self.assertRelated(A, [M, P, Q, Z])
+ self.assertRelated(M, [P, Q, Z])
+ self.assertRelated(P, [M, Q, Z])
+ self.assertRelated(Q, [M, P, Z])
+ self.assertRelated(Z, [M, P, Q])
diff --git a/testbed/django__django/tests/migrations/test_writer.py b/testbed/django__django/tests/migrations/test_writer.py
new file mode 100644
index 0000000000000000000000000000000000000000..33b52bd5385d15727d78aeb361cb930bc3450500
--- /dev/null
+++ b/testbed/django__django/tests/migrations/test_writer.py
@@ -0,0 +1,1003 @@
+import datetime
+import decimal
+import enum
+import functools
+import math
+import os
+import pathlib
+import re
+import sys
+import time
+import uuid
+import zoneinfo
+from types import NoneType
+from unittest import mock
+
+import custom_migration_operations.more_operations
+import custom_migration_operations.operations
+
+from django import get_version
+from django.conf import SettingsReference, settings
+from django.core.validators import EmailValidator, RegexValidator
+from django.db import migrations, models
+from django.db.migrations.serializer import BaseSerializer
+from django.db.migrations.writer import MigrationWriter, OperationWriter
+from django.test import SimpleTestCase
+from django.utils.deconstruct import deconstructible
+from django.utils.functional import SimpleLazyObject
+from django.utils.timezone import get_default_timezone, get_fixed_timezone
+from django.utils.translation import gettext_lazy as _
+
+from .models import FoodManager, FoodQuerySet
+
+
+class DeconstructibleInstances:
+ def deconstruct(self):
+ return ("DeconstructibleInstances", [], {})
+
+
+class Money(decimal.Decimal):
+ def deconstruct(self):
+ return (
+ "%s.%s" % (self.__class__.__module__, self.__class__.__name__),
+ [str(self)],
+ {},
+ )
+
+
+class TestModel1:
+ def upload_to(self):
+ return "/somewhere/dynamic/"
+
+ thing = models.FileField(upload_to=upload_to)
+
+
+class TextEnum(enum.Enum):
+ A = "a-value"
+ B = "value-b"
+
+
+class TextTranslatedEnum(enum.Enum):
+ A = _("a-value")
+ B = _("value-b")
+
+
+class BinaryEnum(enum.Enum):
+ A = b"a-value"
+ B = b"value-b"
+
+
+class IntEnum(enum.IntEnum):
+ A = 1
+ B = 2
+
+
+class IntFlagEnum(enum.IntFlag):
+ A = 1
+ B = 2
+
+
+class OperationWriterTests(SimpleTestCase):
+ def test_empty_signature(self):
+ operation = custom_migration_operations.operations.TestOperation()
+ buff, imports = OperationWriter(operation, indentation=0).serialize()
+ self.assertEqual(imports, {"import custom_migration_operations.operations"})
+ self.assertEqual(
+ buff,
+ "custom_migration_operations.operations.TestOperation(\n),",
+ )
+
+ def test_args_signature(self):
+ operation = custom_migration_operations.operations.ArgsOperation(1, 2)
+ buff, imports = OperationWriter(operation, indentation=0).serialize()
+ self.assertEqual(imports, {"import custom_migration_operations.operations"})
+ self.assertEqual(
+ buff,
+ "custom_migration_operations.operations.ArgsOperation(\n"
+ " arg1=1,\n"
+ " arg2=2,\n"
+ "),",
+ )
+
+ def test_kwargs_signature(self):
+ operation = custom_migration_operations.operations.KwargsOperation(kwarg1=1)
+ buff, imports = OperationWriter(operation, indentation=0).serialize()
+ self.assertEqual(imports, {"import custom_migration_operations.operations"})
+ self.assertEqual(
+ buff,
+ "custom_migration_operations.operations.KwargsOperation(\n"
+ " kwarg1=1,\n"
+ "),",
+ )
+
+ def test_args_kwargs_signature(self):
+ operation = custom_migration_operations.operations.ArgsKwargsOperation(
+ 1, 2, kwarg2=4
+ )
+ buff, imports = OperationWriter(operation, indentation=0).serialize()
+ self.assertEqual(imports, {"import custom_migration_operations.operations"})
+ self.assertEqual(
+ buff,
+ "custom_migration_operations.operations.ArgsKwargsOperation(\n"
+ " arg1=1,\n"
+ " arg2=2,\n"
+ " kwarg2=4,\n"
+ "),",
+ )
+
+ def test_nested_args_signature(self):
+ operation = custom_migration_operations.operations.ArgsOperation(
+ custom_migration_operations.operations.ArgsOperation(1, 2),
+ custom_migration_operations.operations.KwargsOperation(kwarg1=3, kwarg2=4),
+ )
+ buff, imports = OperationWriter(operation, indentation=0).serialize()
+ self.assertEqual(imports, {"import custom_migration_operations.operations"})
+ self.assertEqual(
+ buff,
+ "custom_migration_operations.operations.ArgsOperation(\n"
+ " arg1=custom_migration_operations.operations.ArgsOperation(\n"
+ " arg1=1,\n"
+ " arg2=2,\n"
+ " ),\n"
+ " arg2=custom_migration_operations.operations.KwargsOperation(\n"
+ " kwarg1=3,\n"
+ " kwarg2=4,\n"
+ " ),\n"
+ "),",
+ )
+
+ def test_multiline_args_signature(self):
+ operation = custom_migration_operations.operations.ArgsOperation(
+ "test\n arg1", "test\narg2"
+ )
+ buff, imports = OperationWriter(operation, indentation=0).serialize()
+ self.assertEqual(imports, {"import custom_migration_operations.operations"})
+ self.assertEqual(
+ buff,
+ "custom_migration_operations.operations.ArgsOperation(\n"
+ " arg1='test\\n arg1',\n"
+ " arg2='test\\narg2',\n"
+ "),",
+ )
+
+ def test_expand_args_signature(self):
+ operation = custom_migration_operations.operations.ExpandArgsOperation([1, 2])
+ buff, imports = OperationWriter(operation, indentation=0).serialize()
+ self.assertEqual(imports, {"import custom_migration_operations.operations"})
+ self.assertEqual(
+ buff,
+ "custom_migration_operations.operations.ExpandArgsOperation(\n"
+ " arg=[\n"
+ " 1,\n"
+ " 2,\n"
+ " ],\n"
+ "),",
+ )
+
+ def test_nested_operation_expand_args_signature(self):
+ operation = custom_migration_operations.operations.ExpandArgsOperation(
+ arg=[
+ custom_migration_operations.operations.KwargsOperation(
+ kwarg1=1,
+ kwarg2=2,
+ ),
+ ]
+ )
+ buff, imports = OperationWriter(operation, indentation=0).serialize()
+ self.assertEqual(imports, {"import custom_migration_operations.operations"})
+ self.assertEqual(
+ buff,
+ "custom_migration_operations.operations.ExpandArgsOperation(\n"
+ " arg=[\n"
+ " custom_migration_operations.operations.KwargsOperation(\n"
+ " kwarg1=1,\n"
+ " kwarg2=2,\n"
+ " ),\n"
+ " ],\n"
+ "),",
+ )
+
+
+class WriterTests(SimpleTestCase):
+ """
+ Tests the migration writer (makes migration files from Migration instances)
+ """
+
+ class NestedEnum(enum.IntEnum):
+ A = 1
+ B = 2
+
+ class NestedChoices(models.TextChoices):
+ X = "X", "X value"
+ Y = "Y", "Y value"
+
+ def safe_exec(self, string, value=None):
+ d = {}
+ try:
+ exec(string, globals(), d)
+ except Exception as e:
+ if value:
+ self.fail(
+ "Could not exec %r (from value %r): %s" % (string.strip(), value, e)
+ )
+ else:
+ self.fail("Could not exec %r: %s" % (string.strip(), e))
+ return d
+
+ def serialize_round_trip(self, value):
+ string, imports = MigrationWriter.serialize(value)
+ return self.safe_exec(
+ "%s\ntest_value_result = %s" % ("\n".join(imports), string), value
+ )["test_value_result"]
+
+ def assertSerializedEqual(self, value):
+ self.assertEqual(self.serialize_round_trip(value), value)
+
+ def assertSerializedResultEqual(self, value, target):
+ self.assertEqual(MigrationWriter.serialize(value), target)
+
+ def assertSerializedFieldEqual(self, value):
+ new_value = self.serialize_round_trip(value)
+ self.assertEqual(value.__class__, new_value.__class__)
+ self.assertEqual(value.max_length, new_value.max_length)
+ self.assertEqual(value.null, new_value.null)
+ self.assertEqual(value.unique, new_value.unique)
+
+ def test_serialize_numbers(self):
+ self.assertSerializedEqual(1)
+ self.assertSerializedEqual(1.2)
+ self.assertTrue(math.isinf(self.serialize_round_trip(float("inf"))))
+ self.assertTrue(math.isinf(self.serialize_round_trip(float("-inf"))))
+ self.assertTrue(math.isnan(self.serialize_round_trip(float("nan"))))
+
+ self.assertSerializedEqual(decimal.Decimal("1.3"))
+ self.assertSerializedResultEqual(
+ decimal.Decimal("1.3"), ("Decimal('1.3')", {"from decimal import Decimal"})
+ )
+
+ self.assertSerializedEqual(Money("1.3"))
+ self.assertSerializedResultEqual(
+ Money("1.3"),
+ ("migrations.test_writer.Money('1.3')", {"import migrations.test_writer"}),
+ )
+
+ def test_serialize_constants(self):
+ self.assertSerializedEqual(None)
+ self.assertSerializedEqual(True)
+ self.assertSerializedEqual(False)
+
+ def test_serialize_strings(self):
+ self.assertSerializedEqual(b"foobar")
+ string, imports = MigrationWriter.serialize(b"foobar")
+ self.assertEqual(string, "b'foobar'")
+ self.assertSerializedEqual("föobár")
+ string, imports = MigrationWriter.serialize("foobar")
+ self.assertEqual(string, "'foobar'")
+
+ def test_serialize_multiline_strings(self):
+ self.assertSerializedEqual(b"foo\nbar")
+ string, imports = MigrationWriter.serialize(b"foo\nbar")
+ self.assertEqual(string, "b'foo\\nbar'")
+ self.assertSerializedEqual("föo\nbár")
+ string, imports = MigrationWriter.serialize("foo\nbar")
+ self.assertEqual(string, "'foo\\nbar'")
+
+ def test_serialize_collections(self):
+ self.assertSerializedEqual({1: 2})
+ self.assertSerializedEqual(["a", 2, True, None])
+ self.assertSerializedEqual({2, 3, "eighty"})
+ self.assertSerializedEqual({"lalalala": ["yeah", "no", "maybe"]})
+ self.assertSerializedEqual(_("Hello"))
+
+ def test_serialize_builtin_types(self):
+ self.assertSerializedEqual([list, tuple, dict, set, frozenset])
+ self.assertSerializedResultEqual(
+ [list, tuple, dict, set, frozenset],
+ ("[list, tuple, dict, set, frozenset]", set()),
+ )
+
+ def test_serialize_lazy_objects(self):
+ pattern = re.compile(r"^foo$")
+ lazy_pattern = SimpleLazyObject(lambda: pattern)
+ self.assertEqual(self.serialize_round_trip(lazy_pattern), pattern)
+
+ def test_serialize_enums(self):
+ self.assertSerializedResultEqual(
+ TextEnum.A,
+ ("migrations.test_writer.TextEnum['A']", {"import migrations.test_writer"}),
+ )
+ self.assertSerializedResultEqual(
+ TextTranslatedEnum.A,
+ (
+ "migrations.test_writer.TextTranslatedEnum['A']",
+ {"import migrations.test_writer"},
+ ),
+ )
+ self.assertSerializedResultEqual(
+ BinaryEnum.A,
+ (
+ "migrations.test_writer.BinaryEnum['A']",
+ {"import migrations.test_writer"},
+ ),
+ )
+ self.assertSerializedResultEqual(
+ IntEnum.B,
+ ("migrations.test_writer.IntEnum['B']", {"import migrations.test_writer"}),
+ )
+ self.assertSerializedResultEqual(
+ self.NestedEnum.A,
+ (
+ "migrations.test_writer.WriterTests.NestedEnum['A']",
+ {"import migrations.test_writer"},
+ ),
+ )
+ self.assertSerializedEqual(self.NestedEnum.A)
+
+ field = models.CharField(
+ default=TextEnum.B, choices=[(m.value, m) for m in TextEnum]
+ )
+ string = MigrationWriter.serialize(field)[0]
+ self.assertEqual(
+ string,
+ "models.CharField(choices=["
+ "('a-value', migrations.test_writer.TextEnum['A']), "
+ "('value-b', migrations.test_writer.TextEnum['B'])], "
+ "default=migrations.test_writer.TextEnum['B'])",
+ )
+ field = models.CharField(
+ default=TextTranslatedEnum.A,
+ choices=[(m.value, m) for m in TextTranslatedEnum],
+ )
+ string = MigrationWriter.serialize(field)[0]
+ self.assertEqual(
+ string,
+ "models.CharField(choices=["
+ "('a-value', migrations.test_writer.TextTranslatedEnum['A']), "
+ "('value-b', migrations.test_writer.TextTranslatedEnum['B'])], "
+ "default=migrations.test_writer.TextTranslatedEnum['A'])",
+ )
+ field = models.CharField(
+ default=BinaryEnum.B, choices=[(m.value, m) for m in BinaryEnum]
+ )
+ string = MigrationWriter.serialize(field)[0]
+ self.assertEqual(
+ string,
+ "models.CharField(choices=["
+ "(b'a-value', migrations.test_writer.BinaryEnum['A']), "
+ "(b'value-b', migrations.test_writer.BinaryEnum['B'])], "
+ "default=migrations.test_writer.BinaryEnum['B'])",
+ )
+ field = models.IntegerField(
+ default=IntEnum.A, choices=[(m.value, m) for m in IntEnum]
+ )
+ string = MigrationWriter.serialize(field)[0]
+ self.assertEqual(
+ string,
+ "models.IntegerField(choices=["
+ "(1, migrations.test_writer.IntEnum['A']), "
+ "(2, migrations.test_writer.IntEnum['B'])], "
+ "default=migrations.test_writer.IntEnum['A'])",
+ )
+
+ def test_serialize_enum_flags(self):
+ self.assertSerializedResultEqual(
+ IntFlagEnum.A,
+ (
+ "migrations.test_writer.IntFlagEnum['A']",
+ {"import migrations.test_writer"},
+ ),
+ )
+ self.assertSerializedResultEqual(
+ IntFlagEnum.B,
+ (
+ "migrations.test_writer.IntFlagEnum['B']",
+ {"import migrations.test_writer"},
+ ),
+ )
+ field = models.IntegerField(
+ default=IntFlagEnum.A, choices=[(m.value, m) for m in IntFlagEnum]
+ )
+ string = MigrationWriter.serialize(field)[0]
+ self.assertEqual(
+ string,
+ "models.IntegerField(choices=["
+ "(1, migrations.test_writer.IntFlagEnum['A']), "
+ "(2, migrations.test_writer.IntFlagEnum['B'])], "
+ "default=migrations.test_writer.IntFlagEnum['A'])",
+ )
+ self.assertSerializedResultEqual(
+ IntFlagEnum.A | IntFlagEnum.B,
+ (
+ "migrations.test_writer.IntFlagEnum['A'] | "
+ "migrations.test_writer.IntFlagEnum['B']",
+ {"import migrations.test_writer"},
+ ),
+ )
+
+ def test_serialize_choices(self):
+ class TextChoices(models.TextChoices):
+ A = "A", "A value"
+ B = "B", "B value"
+
+ class IntegerChoices(models.IntegerChoices):
+ A = 1, "One"
+ B = 2, "Two"
+
+ class DateChoices(datetime.date, models.Choices):
+ DATE_1 = 1969, 7, 20, "First date"
+ DATE_2 = 1969, 11, 19, "Second date"
+
+ self.assertSerializedResultEqual(TextChoices.A, ("'A'", set()))
+ self.assertSerializedResultEqual(IntegerChoices.A, ("1", set()))
+ self.assertSerializedResultEqual(
+ DateChoices.DATE_1,
+ ("datetime.date(1969, 7, 20)", {"import datetime"}),
+ )
+ field = models.CharField(default=TextChoices.B, choices=TextChoices)
+ string = MigrationWriter.serialize(field)[0]
+ self.assertEqual(
+ string,
+ "models.CharField(choices=[('A', 'A value'), ('B', 'B value')], "
+ "default='B')",
+ )
+ field = models.IntegerField(default=IntegerChoices.B, choices=IntegerChoices)
+ string = MigrationWriter.serialize(field)[0]
+ self.assertEqual(
+ string,
+ "models.IntegerField(choices=[(1, 'One'), (2, 'Two')], default=2)",
+ )
+ field = models.DateField(default=DateChoices.DATE_2, choices=DateChoices)
+ string = MigrationWriter.serialize(field)[0]
+ self.assertEqual(
+ string,
+ "models.DateField(choices=["
+ "(datetime.date(1969, 7, 20), 'First date'), "
+ "(datetime.date(1969, 11, 19), 'Second date')], "
+ "default=datetime.date(1969, 11, 19))",
+ )
+
+ def test_serialize_nested_class(self):
+ for nested_cls in [self.NestedEnum, self.NestedChoices]:
+ cls_name = nested_cls.__name__
+ with self.subTest(cls_name):
+ self.assertSerializedResultEqual(
+ nested_cls,
+ (
+ "migrations.test_writer.WriterTests.%s" % cls_name,
+ {"import migrations.test_writer"},
+ ),
+ )
+
+ def test_serialize_uuid(self):
+ self.assertSerializedEqual(uuid.uuid1())
+ self.assertSerializedEqual(uuid.uuid4())
+
+ uuid_a = uuid.UUID("5c859437-d061-4847-b3f7-e6b78852f8c8")
+ uuid_b = uuid.UUID("c7853ec1-2ea3-4359-b02d-b54e8f1bcee2")
+ self.assertSerializedResultEqual(
+ uuid_a,
+ ("uuid.UUID('5c859437-d061-4847-b3f7-e6b78852f8c8')", {"import uuid"}),
+ )
+ self.assertSerializedResultEqual(
+ uuid_b,
+ ("uuid.UUID('c7853ec1-2ea3-4359-b02d-b54e8f1bcee2')", {"import uuid"}),
+ )
+
+ field = models.UUIDField(
+ choices=((uuid_a, "UUID A"), (uuid_b, "UUID B")), default=uuid_a
+ )
+ string = MigrationWriter.serialize(field)[0]
+ self.assertEqual(
+ string,
+ "models.UUIDField(choices=["
+ "(uuid.UUID('5c859437-d061-4847-b3f7-e6b78852f8c8'), 'UUID A'), "
+ "(uuid.UUID('c7853ec1-2ea3-4359-b02d-b54e8f1bcee2'), 'UUID B')], "
+ "default=uuid.UUID('5c859437-d061-4847-b3f7-e6b78852f8c8'))",
+ )
+
+ def test_serialize_pathlib(self):
+ # Pure path objects work in all platforms.
+ self.assertSerializedEqual(pathlib.PurePosixPath())
+ self.assertSerializedEqual(pathlib.PureWindowsPath())
+ path = pathlib.PurePosixPath("/path/file.txt")
+ expected = ("pathlib.PurePosixPath('/path/file.txt')", {"import pathlib"})
+ self.assertSerializedResultEqual(path, expected)
+ path = pathlib.PureWindowsPath("A:\\File.txt")
+ expected = ("pathlib.PureWindowsPath('A:/File.txt')", {"import pathlib"})
+ self.assertSerializedResultEqual(path, expected)
+ # Concrete path objects work on supported platforms.
+ if sys.platform == "win32":
+ self.assertSerializedEqual(pathlib.WindowsPath.cwd())
+ path = pathlib.WindowsPath("A:\\File.txt")
+ expected = ("pathlib.PureWindowsPath('A:/File.txt')", {"import pathlib"})
+ self.assertSerializedResultEqual(path, expected)
+ else:
+ self.assertSerializedEqual(pathlib.PosixPath.cwd())
+ path = pathlib.PosixPath("/path/file.txt")
+ expected = ("pathlib.PurePosixPath('/path/file.txt')", {"import pathlib"})
+ self.assertSerializedResultEqual(path, expected)
+
+ field = models.FilePathField(path=pathlib.PurePosixPath("/home/user"))
+ string, imports = MigrationWriter.serialize(field)
+ self.assertEqual(
+ string,
+ "models.FilePathField(path=pathlib.PurePosixPath('/home/user'))",
+ )
+ self.assertIn("import pathlib", imports)
+
+ def test_serialize_path_like(self):
+ with os.scandir(os.path.dirname(__file__)) as entries:
+ path_like = list(entries)[0]
+ expected = (repr(path_like.path), {})
+ self.assertSerializedResultEqual(path_like, expected)
+
+ field = models.FilePathField(path=path_like)
+ string = MigrationWriter.serialize(field)[0]
+ self.assertEqual(string, "models.FilePathField(path=%r)" % path_like.path)
+
+ def test_serialize_functions(self):
+ with self.assertRaisesMessage(ValueError, "Cannot serialize function: lambda"):
+ self.assertSerializedEqual(lambda x: 42)
+ self.assertSerializedEqual(models.SET_NULL)
+ string, imports = MigrationWriter.serialize(models.SET(42))
+ self.assertEqual(string, "models.SET(42)")
+ self.serialize_round_trip(models.SET(42))
+
+ def test_serialize_datetime(self):
+ self.assertSerializedEqual(datetime.datetime.now())
+ self.assertSerializedEqual(datetime.datetime.now)
+ self.assertSerializedEqual(datetime.datetime.today())
+ self.assertSerializedEqual(datetime.datetime.today)
+ self.assertSerializedEqual(datetime.date.today())
+ self.assertSerializedEqual(datetime.date.today)
+ self.assertSerializedEqual(datetime.datetime.now().time())
+ self.assertSerializedEqual(
+ datetime.datetime(2014, 1, 1, 1, 1, tzinfo=get_default_timezone())
+ )
+ self.assertSerializedEqual(
+ datetime.datetime(2013, 12, 31, 22, 1, tzinfo=get_fixed_timezone(180))
+ )
+ self.assertSerializedResultEqual(
+ datetime.datetime(2014, 1, 1, 1, 1),
+ ("datetime.datetime(2014, 1, 1, 1, 1)", {"import datetime"}),
+ )
+ self.assertSerializedResultEqual(
+ datetime.datetime(2012, 1, 1, 1, 1, tzinfo=datetime.timezone.utc),
+ (
+ "datetime.datetime(2012, 1, 1, 1, 1, tzinfo=datetime.timezone.utc)",
+ {"import datetime"},
+ ),
+ )
+ self.assertSerializedResultEqual(
+ datetime.datetime(
+ 2012, 1, 1, 2, 1, tzinfo=zoneinfo.ZoneInfo("Europe/Paris")
+ ),
+ (
+ "datetime.datetime(2012, 1, 1, 1, 1, tzinfo=datetime.timezone.utc)",
+ {"import datetime"},
+ ),
+ )
+
+ def test_serialize_fields(self):
+ self.assertSerializedFieldEqual(models.CharField(max_length=255))
+ self.assertSerializedResultEqual(
+ models.CharField(max_length=255),
+ ("models.CharField(max_length=255)", {"from django.db import models"}),
+ )
+ self.assertSerializedFieldEqual(models.TextField(null=True, blank=True))
+ self.assertSerializedResultEqual(
+ models.TextField(null=True, blank=True),
+ (
+ "models.TextField(blank=True, null=True)",
+ {"from django.db import models"},
+ ),
+ )
+
+ def test_serialize_settings(self):
+ self.assertSerializedEqual(
+ SettingsReference(settings.AUTH_USER_MODEL, "AUTH_USER_MODEL")
+ )
+ self.assertSerializedResultEqual(
+ SettingsReference("someapp.model", "AUTH_USER_MODEL"),
+ ("settings.AUTH_USER_MODEL", {"from django.conf import settings"}),
+ )
+
+ def test_serialize_iterators(self):
+ self.assertSerializedResultEqual(
+ ((x, x * x) for x in range(3)), ("((0, 0), (1, 1), (2, 4))", set())
+ )
+
+ def test_serialize_compiled_regex(self):
+ """
+ Make sure compiled regex can be serialized.
+ """
+ regex = re.compile(r"^\w+$")
+ self.assertSerializedEqual(regex)
+
+ def test_serialize_class_based_validators(self):
+ """
+ Ticket #22943: Test serialization of class-based validators, including
+ compiled regexes.
+ """
+ validator = RegexValidator(message="hello")
+ string = MigrationWriter.serialize(validator)[0]
+ self.assertEqual(
+ string, "django.core.validators.RegexValidator(message='hello')"
+ )
+ self.serialize_round_trip(validator)
+
+ # Test with a compiled regex.
+ validator = RegexValidator(regex=re.compile(r"^\w+$"))
+ string = MigrationWriter.serialize(validator)[0]
+ self.assertEqual(
+ string,
+ "django.core.validators.RegexValidator(regex=re.compile('^\\\\w+$'))",
+ )
+ self.serialize_round_trip(validator)
+
+ # Test a string regex with flag
+ validator = RegexValidator(r"^[0-9]+$", flags=re.S)
+ string = MigrationWriter.serialize(validator)[0]
+ self.assertEqual(
+ string,
+ "django.core.validators.RegexValidator('^[0-9]+$', "
+ "flags=re.RegexFlag['DOTALL'])",
+ )
+ self.serialize_round_trip(validator)
+
+ # Test message and code
+ validator = RegexValidator("^[-a-zA-Z0-9_]+$", "Invalid", "invalid")
+ string = MigrationWriter.serialize(validator)[0]
+ self.assertEqual(
+ string,
+ "django.core.validators.RegexValidator('^[-a-zA-Z0-9_]+$', 'Invalid', "
+ "'invalid')",
+ )
+ self.serialize_round_trip(validator)
+
+ # Test with a subclass.
+ validator = EmailValidator(message="hello")
+ string = MigrationWriter.serialize(validator)[0]
+ self.assertEqual(
+ string, "django.core.validators.EmailValidator(message='hello')"
+ )
+ self.serialize_round_trip(validator)
+
+ validator = deconstructible(path="migrations.test_writer.EmailValidator")(
+ EmailValidator
+ )(message="hello")
+ string = MigrationWriter.serialize(validator)[0]
+ self.assertEqual(
+ string, "migrations.test_writer.EmailValidator(message='hello')"
+ )
+
+ validator = deconstructible(path="custom.EmailValidator")(EmailValidator)(
+ message="hello"
+ )
+ with self.assertRaisesMessage(ImportError, "No module named 'custom'"):
+ MigrationWriter.serialize(validator)
+
+ validator = deconstructible(path="django.core.validators.EmailValidator2")(
+ EmailValidator
+ )(message="hello")
+ with self.assertRaisesMessage(
+ ValueError,
+ "Could not find object EmailValidator2 in django.core.validators.",
+ ):
+ MigrationWriter.serialize(validator)
+
+ def test_serialize_complex_func_index(self):
+ index = models.Index(
+ models.Func("rating", function="ABS"),
+ models.Case(
+ models.When(name="special", then=models.Value("X")),
+ default=models.Value("other"),
+ ),
+ models.ExpressionWrapper(
+ models.F("pages"),
+ output_field=models.IntegerField(),
+ ),
+ models.OrderBy(models.F("name").desc()),
+ name="complex_func_index",
+ )
+ string, imports = MigrationWriter.serialize(index)
+ self.assertEqual(
+ string,
+ "models.Index(models.Func('rating', function='ABS'), "
+ "models.Case(models.When(name='special', then=models.Value('X')), "
+ "default=models.Value('other')), "
+ "models.ExpressionWrapper("
+ "models.F('pages'), output_field=models.IntegerField()), "
+ "models.OrderBy(models.OrderBy(models.F('name'), descending=True)), "
+ "name='complex_func_index')",
+ )
+ self.assertEqual(imports, {"from django.db import models"})
+
+ def test_serialize_empty_nonempty_tuple(self):
+ """
+ Ticket #22679: makemigrations generates invalid code for (an empty
+ tuple) default_permissions = ()
+ """
+ empty_tuple = ()
+ one_item_tuple = ("a",)
+ many_items_tuple = ("a", "b", "c")
+ self.assertSerializedEqual(empty_tuple)
+ self.assertSerializedEqual(one_item_tuple)
+ self.assertSerializedEqual(many_items_tuple)
+
+ def test_serialize_range(self):
+ string, imports = MigrationWriter.serialize(range(1, 5))
+ self.assertEqual(string, "range(1, 5)")
+ self.assertEqual(imports, set())
+
+ def test_serialize_builtins(self):
+ string, imports = MigrationWriter.serialize(range)
+ self.assertEqual(string, "range")
+ self.assertEqual(imports, set())
+
+ def test_serialize_unbound_method_reference(self):
+ """An unbound method used within a class body can be serialized."""
+ self.serialize_round_trip(TestModel1.thing)
+
+ def test_serialize_local_function_reference(self):
+ """A reference in a local scope can't be serialized."""
+
+ class TestModel2:
+ def upload_to(self):
+ return "somewhere dynamic"
+
+ thing = models.FileField(upload_to=upload_to)
+
+ with self.assertRaisesMessage(
+ ValueError, "Could not find function upload_to in migrations.test_writer"
+ ):
+ self.serialize_round_trip(TestModel2.thing)
+
+ def test_serialize_managers(self):
+ self.assertSerializedEqual(models.Manager())
+ self.assertSerializedResultEqual(
+ FoodQuerySet.as_manager(),
+ (
+ "migrations.models.FoodQuerySet.as_manager()",
+ {"import migrations.models"},
+ ),
+ )
+ self.assertSerializedEqual(FoodManager("a", "b"))
+ self.assertSerializedEqual(FoodManager("x", "y", c=3, d=4))
+
+ def test_serialize_frozensets(self):
+ self.assertSerializedEqual(frozenset())
+ self.assertSerializedEqual(frozenset("let it go"))
+
+ def test_serialize_set(self):
+ self.assertSerializedEqual(set())
+ self.assertSerializedResultEqual(set(), ("set()", set()))
+ self.assertSerializedEqual({"a"})
+ self.assertSerializedResultEqual({"a"}, ("{'a'}", set()))
+
+ def test_serialize_timedelta(self):
+ self.assertSerializedEqual(datetime.timedelta())
+ self.assertSerializedEqual(datetime.timedelta(minutes=42))
+
+ def test_serialize_functools_partial(self):
+ value = functools.partial(datetime.timedelta, 1, seconds=2)
+ result = self.serialize_round_trip(value)
+ self.assertEqual(result.func, value.func)
+ self.assertEqual(result.args, value.args)
+ self.assertEqual(result.keywords, value.keywords)
+
+ def test_serialize_functools_partialmethod(self):
+ value = functools.partialmethod(datetime.timedelta, 1, seconds=2)
+ result = self.serialize_round_trip(value)
+ self.assertIsInstance(result, functools.partialmethod)
+ self.assertEqual(result.func, value.func)
+ self.assertEqual(result.args, value.args)
+ self.assertEqual(result.keywords, value.keywords)
+
+ def test_serialize_type_none(self):
+ self.assertSerializedEqual(NoneType)
+
+ def test_serialize_type_model(self):
+ self.assertSerializedEqual(models.Model)
+ self.assertSerializedResultEqual(
+ MigrationWriter.serialize(models.Model),
+ ("('models.Model', {'from django.db import models'})", set()),
+ )
+
+ def test_simple_migration(self):
+ """
+ Tests serializing a simple migration.
+ """
+ fields = {
+ "charfield": models.DateTimeField(default=datetime.datetime.now),
+ "datetimefield": models.DateTimeField(default=datetime.datetime.now),
+ }
+
+ options = {
+ "verbose_name": "My model",
+ "verbose_name_plural": "My models",
+ }
+
+ migration = type(
+ "Migration",
+ (migrations.Migration,),
+ {
+ "operations": [
+ migrations.CreateModel(
+ "MyModel", tuple(fields.items()), options, (models.Model,)
+ ),
+ migrations.CreateModel(
+ "MyModel2", tuple(fields.items()), bases=(models.Model,)
+ ),
+ migrations.CreateModel(
+ name="MyModel3",
+ fields=tuple(fields.items()),
+ options=options,
+ bases=(models.Model,),
+ ),
+ migrations.DeleteModel("MyModel"),
+ migrations.AddField(
+ "OtherModel", "datetimefield", fields["datetimefield"]
+ ),
+ ],
+ "dependencies": [("testapp", "some_other_one")],
+ },
+ )
+ writer = MigrationWriter(migration)
+ output = writer.as_string()
+ # We don't test the output formatting - that's too fragile.
+ # Just make sure it runs for now, and that things look alright.
+ result = self.safe_exec(output)
+ self.assertIn("Migration", result)
+
+ def test_migration_path(self):
+ test_apps = [
+ "migrations.migrations_test_apps.normal",
+ "migrations.migrations_test_apps.with_package_model",
+ "migrations.migrations_test_apps.without_init_file",
+ ]
+
+ base_dir = os.path.dirname(os.path.dirname(__file__))
+
+ for app in test_apps:
+ with self.modify_settings(INSTALLED_APPS={"append": app}):
+ migration = migrations.Migration("0001_initial", app.split(".")[-1])
+ expected_path = os.path.join(
+ base_dir, *(app.split(".") + ["migrations", "0001_initial.py"])
+ )
+ writer = MigrationWriter(migration)
+ self.assertEqual(writer.path, expected_path)
+
+ def test_custom_operation(self):
+ migration = type(
+ "Migration",
+ (migrations.Migration,),
+ {
+ "operations": [
+ custom_migration_operations.operations.TestOperation(),
+ custom_migration_operations.operations.CreateModel(),
+ migrations.CreateModel("MyModel", (), {}, (models.Model,)),
+ custom_migration_operations.more_operations.TestOperation(),
+ ],
+ "dependencies": [],
+ },
+ )
+ writer = MigrationWriter(migration)
+ output = writer.as_string()
+ result = self.safe_exec(output)
+ self.assertIn("custom_migration_operations", result)
+ self.assertNotEqual(
+ result["custom_migration_operations"].operations.TestOperation,
+ result["custom_migration_operations"].more_operations.TestOperation,
+ )
+
+ def test_sorted_imports(self):
+ """
+ #24155 - Tests ordering of imports.
+ """
+ migration = type(
+ "Migration",
+ (migrations.Migration,),
+ {
+ "operations": [
+ migrations.AddField(
+ "mymodel",
+ "myfield",
+ models.DateTimeField(
+ default=datetime.datetime(
+ 2012, 1, 1, 1, 1, tzinfo=datetime.timezone.utc
+ ),
+ ),
+ ),
+ migrations.AddField(
+ "mymodel",
+ "myfield2",
+ models.FloatField(default=time.time),
+ ),
+ ]
+ },
+ )
+ writer = MigrationWriter(migration)
+ output = writer.as_string()
+ self.assertIn(
+ "import datetime\nimport time\nfrom django.db import migrations, models\n",
+ output,
+ )
+
+ def test_migration_file_header_comments(self):
+ """
+ Test comments at top of file.
+ """
+ migration = type("Migration", (migrations.Migration,), {"operations": []})
+ dt = datetime.datetime(2015, 7, 31, 4, 40, 0, 0, tzinfo=datetime.timezone.utc)
+ with mock.patch("django.db.migrations.writer.now", lambda: dt):
+ for include_header in (True, False):
+ with self.subTest(include_header=include_header):
+ writer = MigrationWriter(migration, include_header)
+ output = writer.as_string()
+
+ self.assertEqual(
+ include_header,
+ output.startswith(
+ "# Generated by Django %s on 2015-07-31 04:40\n\n"
+ % get_version()
+ ),
+ )
+ if not include_header:
+ # Make sure the output starts with something that's not
+ # a comment or indentation or blank line
+ self.assertRegex(
+ output.splitlines(keepends=True)[0], r"^[^#\s]+"
+ )
+
+ def test_models_import_omitted(self):
+ """
+ django.db.models shouldn't be imported if unused.
+ """
+ migration = type(
+ "Migration",
+ (migrations.Migration,),
+ {
+ "operations": [
+ migrations.AlterModelOptions(
+ name="model",
+ options={
+ "verbose_name": "model",
+ "verbose_name_plural": "models",
+ },
+ ),
+ ]
+ },
+ )
+ writer = MigrationWriter(migration)
+ output = writer.as_string()
+ self.assertIn("from django.db import migrations\n", output)
+
+ def test_deconstruct_class_arguments(self):
+ # Yes, it doesn't make sense to use a class as a default for a
+ # CharField. It does make sense for custom fields though, for example
+ # an enumfield that takes the enum class as an argument.
+ string = MigrationWriter.serialize(
+ models.CharField(default=DeconstructibleInstances)
+ )[0]
+ self.assertEqual(
+ string,
+ "models.CharField(default=migrations.test_writer.DeconstructibleInstances)",
+ )
+
+ def test_register_serializer(self):
+ class ComplexSerializer(BaseSerializer):
+ def serialize(self):
+ return "complex(%r)" % self.value, {}
+
+ MigrationWriter.register_serializer(complex, ComplexSerializer)
+ self.assertSerializedEqual(complex(1, 2))
+ MigrationWriter.unregister_serializer(complex)
+ with self.assertRaisesMessage(ValueError, "Cannot serialize: (1+2j)"):
+ self.assertSerializedEqual(complex(1, 2))
+
+ def test_register_non_serializer(self):
+ with self.assertRaisesMessage(
+ ValueError, "'TestModel1' must inherit from 'BaseSerializer'."
+ ):
+ MigrationWriter.register_serializer(complex, TestModel1)
diff --git a/testbed/django__django/tests/migrations2/__init__.py b/testbed/django__django/tests/migrations2/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testbed/django__django/tests/migrations2/models.py b/testbed/django__django/tests/migrations2/models.py
new file mode 100644
index 0000000000000000000000000000000000000000..3ea7a1df09efaa65ec4e2c9dc0d9043ec7a31120
--- /dev/null
+++ b/testbed/django__django/tests/migrations2/models.py
@@ -0,0 +1 @@
+# Required for migration detection (#22645)
diff --git a/testbed/django__django/tests/migrations2/test_migrations_2/0001_initial.py b/testbed/django__django/tests/migrations2/test_migrations_2/0001_initial.py
new file mode 100644
index 0000000000000000000000000000000000000000..4575f4d632c5c04870ecc291a56b95b6e7c8dc1b
--- /dev/null
+++ b/testbed/django__django/tests/migrations2/test_migrations_2/0001_initial.py
@@ -0,0 +1,18 @@
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+ dependencies = [("migrations", "0002_second")]
+
+ operations = [
+ migrations.CreateModel(
+ "OtherAuthor",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ("name", models.CharField(max_length=255)),
+ ("slug", models.SlugField(null=True)),
+ ("age", models.IntegerField(default=0)),
+ ("silly_field", models.BooleanField(default=False)),
+ ],
+ ),
+ ]
diff --git a/testbed/django__django/tests/migrations2/test_migrations_2/__init__.py b/testbed/django__django/tests/migrations2/test_migrations_2/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testbed/django__django/tests/migrations2/test_migrations_2_first/0001_initial.py b/testbed/django__django/tests/migrations2/test_migrations_2_first/0001_initial.py
new file mode 100644
index 0000000000000000000000000000000000000000..98c197afa93b7f348f85de0fcc033131a4422a13
--- /dev/null
+++ b/testbed/django__django/tests/migrations2/test_migrations_2_first/0001_initial.py
@@ -0,0 +1,20 @@
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+ dependencies = [
+ ("migrations", "__first__"),
+ ]
+
+ operations = [
+ migrations.CreateModel(
+ "OtherAuthor",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ("name", models.CharField(max_length=255)),
+ ("slug", models.SlugField(null=True)),
+ ("age", models.IntegerField(default=0)),
+ ("silly_field", models.BooleanField(default=False)),
+ ],
+ ),
+ ]
diff --git a/testbed/django__django/tests/migrations2/test_migrations_2_first/0002_second.py b/testbed/django__django/tests/migrations2/test_migrations_2_first/0002_second.py
new file mode 100644
index 0000000000000000000000000000000000000000..5ab497ed3007bcd3eed5b4854c4845627b3db0d3
--- /dev/null
+++ b/testbed/django__django/tests/migrations2/test_migrations_2_first/0002_second.py
@@ -0,0 +1,16 @@
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+ dependencies = [("migrations2", "0001_initial")]
+
+ operations = [
+ migrations.CreateModel(
+ "Bookstore",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ("name", models.CharField(max_length=255)),
+ ("slug", models.SlugField(null=True)),
+ ],
+ ),
+ ]
diff --git a/testbed/django__django/tests/migrations2/test_migrations_2_first/__init__.py b/testbed/django__django/tests/migrations2/test_migrations_2_first/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testbed/django__django/tests/migrations2/test_migrations_2_no_deps/0001_initial.py b/testbed/django__django/tests/migrations2/test_migrations_2_no_deps/0001_initial.py
new file mode 100644
index 0000000000000000000000000000000000000000..68f4bd07f718ae67a5baccbf4fc279ebf4fb8abf
--- /dev/null
+++ b/testbed/django__django/tests/migrations2/test_migrations_2_no_deps/0001_initial.py
@@ -0,0 +1,18 @@
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+ dependencies = []
+
+ operations = [
+ migrations.CreateModel(
+ "OtherAuthor",
+ [
+ ("id", models.AutoField(primary_key=True)),
+ ("name", models.CharField(max_length=255)),
+ ("slug", models.SlugField(null=True)),
+ ("age", models.IntegerField(default=0)),
+ ("silly_field", models.BooleanField(default=False)),
+ ],
+ ),
+ ]
diff --git a/testbed/django__django/tests/migrations2/test_migrations_2_no_deps/__init__.py b/testbed/django__django/tests/migrations2/test_migrations_2_no_deps/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testbed/django__django/tests/model_enums/__init__.py b/testbed/django__django/tests/model_enums/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testbed/django__django/tests/model_enums/tests.py b/testbed/django__django/tests/model_enums/tests.py
new file mode 100644
index 0000000000000000000000000000000000000000..b010b35594e3929151cbfbfb7d54d9ef53a1842f
--- /dev/null
+++ b/testbed/django__django/tests/model_enums/tests.py
@@ -0,0 +1,317 @@
+import datetime
+import decimal
+import ipaddress
+import uuid
+
+from django.db import models
+from django.template import Context, Template
+from django.test import SimpleTestCase
+from django.utils.functional import Promise
+from django.utils.translation import gettext_lazy as _
+
+
+class Suit(models.IntegerChoices):
+ DIAMOND = 1, _("Diamond")
+ SPADE = 2, _("Spade")
+ HEART = 3, _("Heart")
+ CLUB = 4, _("Club")
+
+
+class YearInSchool(models.TextChoices):
+ FRESHMAN = "FR", _("Freshman")
+ SOPHOMORE = "SO", _("Sophomore")
+ JUNIOR = "JR", _("Junior")
+ SENIOR = "SR", _("Senior")
+ GRADUATE = "GR", _("Graduate")
+
+
+class Vehicle(models.IntegerChoices):
+ CAR = 1, "Carriage"
+ TRUCK = 2
+ JET_SKI = 3
+
+ __empty__ = _("(Unknown)")
+
+
+class Gender(models.TextChoices):
+ MALE = "M"
+ FEMALE = "F"
+ NOT_SPECIFIED = "X"
+
+ __empty__ = "(Undeclared)"
+
+
+class ChoicesTests(SimpleTestCase):
+ def test_integerchoices(self):
+ self.assertEqual(
+ Suit.choices, [(1, "Diamond"), (2, "Spade"), (3, "Heart"), (4, "Club")]
+ )
+ self.assertEqual(Suit.labels, ["Diamond", "Spade", "Heart", "Club"])
+ self.assertEqual(Suit.values, [1, 2, 3, 4])
+ self.assertEqual(Suit.names, ["DIAMOND", "SPADE", "HEART", "CLUB"])
+
+ self.assertEqual(repr(Suit.DIAMOND), "Suit.DIAMOND")
+ self.assertEqual(Suit.DIAMOND.label, "Diamond")
+ self.assertEqual(Suit.DIAMOND.value, 1)
+ self.assertEqual(Suit["DIAMOND"], Suit.DIAMOND)
+ self.assertEqual(Suit(1), Suit.DIAMOND)
+
+ self.assertIsInstance(Suit, type(models.Choices))
+ self.assertIsInstance(Suit.DIAMOND, Suit)
+ self.assertIsInstance(Suit.DIAMOND.label, Promise)
+ self.assertIsInstance(Suit.DIAMOND.value, int)
+
+ def test_integerchoices_auto_label(self):
+ self.assertEqual(Vehicle.CAR.label, "Carriage")
+ self.assertEqual(Vehicle.TRUCK.label, "Truck")
+ self.assertEqual(Vehicle.JET_SKI.label, "Jet Ski")
+
+ def test_integerchoices_empty_label(self):
+ self.assertEqual(Vehicle.choices[0], (None, "(Unknown)"))
+ self.assertEqual(Vehicle.labels[0], "(Unknown)")
+ self.assertIsNone(Vehicle.values[0])
+ self.assertEqual(Vehicle.names[0], "__empty__")
+
+ def test_integerchoices_functional_api(self):
+ Place = models.IntegerChoices("Place", "FIRST SECOND THIRD")
+ self.assertEqual(Place.labels, ["First", "Second", "Third"])
+ self.assertEqual(Place.values, [1, 2, 3])
+ self.assertEqual(Place.names, ["FIRST", "SECOND", "THIRD"])
+
+ def test_integerchoices_containment(self):
+ self.assertIn(Suit.DIAMOND, Suit)
+ self.assertIn(1, Suit)
+ self.assertNotIn(0, Suit)
+
+ def test_textchoices(self):
+ self.assertEqual(
+ YearInSchool.choices,
+ [
+ ("FR", "Freshman"),
+ ("SO", "Sophomore"),
+ ("JR", "Junior"),
+ ("SR", "Senior"),
+ ("GR", "Graduate"),
+ ],
+ )
+ self.assertEqual(
+ YearInSchool.labels,
+ ["Freshman", "Sophomore", "Junior", "Senior", "Graduate"],
+ )
+ self.assertEqual(YearInSchool.values, ["FR", "SO", "JR", "SR", "GR"])
+ self.assertEqual(
+ YearInSchool.names,
+ ["FRESHMAN", "SOPHOMORE", "JUNIOR", "SENIOR", "GRADUATE"],
+ )
+
+ self.assertEqual(repr(YearInSchool.FRESHMAN), "YearInSchool.FRESHMAN")
+ self.assertEqual(YearInSchool.FRESHMAN.label, "Freshman")
+ self.assertEqual(YearInSchool.FRESHMAN.value, "FR")
+ self.assertEqual(YearInSchool["FRESHMAN"], YearInSchool.FRESHMAN)
+ self.assertEqual(YearInSchool("FR"), YearInSchool.FRESHMAN)
+
+ self.assertIsInstance(YearInSchool, type(models.Choices))
+ self.assertIsInstance(YearInSchool.FRESHMAN, YearInSchool)
+ self.assertIsInstance(YearInSchool.FRESHMAN.label, Promise)
+ self.assertIsInstance(YearInSchool.FRESHMAN.value, str)
+
+ def test_textchoices_auto_label(self):
+ self.assertEqual(Gender.MALE.label, "Male")
+ self.assertEqual(Gender.FEMALE.label, "Female")
+ self.assertEqual(Gender.NOT_SPECIFIED.label, "Not Specified")
+
+ def test_textchoices_empty_label(self):
+ self.assertEqual(Gender.choices[0], (None, "(Undeclared)"))
+ self.assertEqual(Gender.labels[0], "(Undeclared)")
+ self.assertIsNone(Gender.values[0])
+ self.assertEqual(Gender.names[0], "__empty__")
+
+ def test_textchoices_functional_api(self):
+ Medal = models.TextChoices("Medal", "GOLD SILVER BRONZE")
+ self.assertEqual(Medal.labels, ["Gold", "Silver", "Bronze"])
+ self.assertEqual(Medal.values, ["GOLD", "SILVER", "BRONZE"])
+ self.assertEqual(Medal.names, ["GOLD", "SILVER", "BRONZE"])
+
+ def test_textchoices_containment(self):
+ self.assertIn(YearInSchool.FRESHMAN, YearInSchool)
+ self.assertIn("FR", YearInSchool)
+ self.assertNotIn("XX", YearInSchool)
+
+ def test_textchoices_blank_value(self):
+ class BlankStr(models.TextChoices):
+ EMPTY = "", "(Empty)"
+ ONE = "ONE", "One"
+
+ self.assertEqual(BlankStr.labels, ["(Empty)", "One"])
+ self.assertEqual(BlankStr.values, ["", "ONE"])
+ self.assertEqual(BlankStr.names, ["EMPTY", "ONE"])
+
+ def test_invalid_definition(self):
+ msg = "'str' object cannot be interpreted as an integer"
+ with self.assertRaisesMessage(TypeError, msg):
+
+ class InvalidArgumentEnum(models.IntegerChoices):
+ # A string is not permitted as the second argument to int().
+ ONE = 1, "X", "Invalid"
+
+ msg = "duplicate values found in : PINEAPPLE -> APPLE"
+ with self.assertRaisesMessage(ValueError, msg):
+
+ class Fruit(models.IntegerChoices):
+ APPLE = 1, "Apple"
+ PINEAPPLE = 1, "Pineapple"
+
+ def test_str(self):
+ for test in [Gender, Suit, YearInSchool, Vehicle]:
+ for member in test:
+ with self.subTest(member=member):
+ self.assertEqual(str(test[member.name]), str(member.value))
+
+ def test_templates(self):
+ template = Template("{{ Suit.DIAMOND.label }}|{{ Suit.DIAMOND.value }}")
+ output = template.render(Context({"Suit": Suit}))
+ self.assertEqual(output, "Diamond|1")
+
+ def test_property_names_conflict_with_member_names(self):
+ with self.assertRaises(AttributeError):
+ models.TextChoices("Properties", "choices labels names values")
+
+ def test_label_member(self):
+ # label can be used as a member.
+ Stationery = models.TextChoices("Stationery", "label stamp sticker")
+ self.assertEqual(Stationery.label.label, "Label")
+ self.assertEqual(Stationery.label.value, "label")
+ self.assertEqual(Stationery.label.name, "label")
+
+ def test_do_not_call_in_templates_member(self):
+ # do_not_call_in_templates is not implicitly treated as a member.
+ Special = models.IntegerChoices("Special", "do_not_call_in_templates")
+ self.assertEqual(
+ Special.do_not_call_in_templates.label,
+ "Do Not Call In Templates",
+ )
+ self.assertEqual(Special.do_not_call_in_templates.value, 1)
+ self.assertEqual(
+ Special.do_not_call_in_templates.name,
+ "do_not_call_in_templates",
+ )
+
+
+class Separator(bytes, models.Choices):
+ FS = b"\x1c", "File Separator"
+ GS = b"\x1d", "Group Separator"
+ RS = b"\x1e", "Record Separator"
+ US = b"\x1f", "Unit Separator"
+
+
+class Constants(float, models.Choices):
+ PI = 3.141592653589793, "π"
+ TAU = 6.283185307179586, "τ"
+
+
+class Set(frozenset, models.Choices):
+ A = {1, 2}
+ B = {2, 3}
+ UNION = A | B
+ DIFFERENCE = A - B
+ INTERSECTION = A & B
+
+
+class MoonLandings(datetime.date, models.Choices):
+ APOLLO_11 = 1969, 7, 20, "Apollo 11 (Eagle)"
+ APOLLO_12 = 1969, 11, 19, "Apollo 12 (Intrepid)"
+ APOLLO_14 = 1971, 2, 5, "Apollo 14 (Antares)"
+ APOLLO_15 = 1971, 7, 30, "Apollo 15 (Falcon)"
+ APOLLO_16 = 1972, 4, 21, "Apollo 16 (Orion)"
+ APOLLO_17 = 1972, 12, 11, "Apollo 17 (Challenger)"
+
+
+class DateAndTime(datetime.datetime, models.Choices):
+ A = 2010, 10, 10, 10, 10, 10
+ B = 2011, 11, 11, 11, 11, 11
+ C = 2012, 12, 12, 12, 12, 12
+
+
+class MealTimes(datetime.time, models.Choices):
+ BREAKFAST = 7, 0
+ LUNCH = 13, 0
+ DINNER = 18, 30
+
+
+class Frequency(datetime.timedelta, models.Choices):
+ WEEK = 0, 0, 0, 0, 0, 0, 1, "Week"
+ DAY = 1, "Day"
+ HOUR = 0, 0, 0, 0, 0, 1, "Hour"
+ MINUTE = 0, 0, 0, 0, 1, "Hour"
+ SECOND = 0, 1, "Second"
+
+
+class Number(decimal.Decimal, models.Choices):
+ E = 2.718281828459045, "e"
+ PI = "3.141592653589793", "π"
+ TAU = decimal.Decimal("6.283185307179586"), "τ"
+
+
+class IPv4Address(ipaddress.IPv4Address, models.Choices):
+ LOCALHOST = "127.0.0.1", "Localhost"
+ GATEWAY = "192.168.0.1", "Gateway"
+ BROADCAST = "192.168.0.255", "Broadcast"
+
+
+class IPv6Address(ipaddress.IPv6Address, models.Choices):
+ LOCALHOST = "::1", "Localhost"
+ UNSPECIFIED = "::", "Unspecified"
+
+
+class IPv4Network(ipaddress.IPv4Network, models.Choices):
+ LOOPBACK = "127.0.0.0/8", "Loopback"
+ LINK_LOCAL = "169.254.0.0/16", "Link-Local"
+ PRIVATE_USE_A = "10.0.0.0/8", "Private-Use (Class A)"
+
+
+class IPv6Network(ipaddress.IPv6Network, models.Choices):
+ LOOPBACK = "::1/128", "Loopback"
+ UNSPECIFIED = "::/128", "Unspecified"
+ UNIQUE_LOCAL = "fc00::/7", "Unique-Local"
+ LINK_LOCAL_UNICAST = "fe80::/10", "Link-Local Unicast"
+
+
+class CustomChoicesTests(SimpleTestCase):
+ def test_labels_valid(self):
+ enums = (
+ Separator,
+ Constants,
+ Set,
+ MoonLandings,
+ DateAndTime,
+ MealTimes,
+ Frequency,
+ Number,
+ IPv4Address,
+ IPv6Address,
+ IPv4Network,
+ IPv6Network,
+ )
+ for choice_enum in enums:
+ with self.subTest(choice_enum.__name__):
+ self.assertNotIn(None, choice_enum.labels)
+
+ def test_bool_unsupported(self):
+ msg = "type 'bool' is not an acceptable base type"
+ with self.assertRaisesMessage(TypeError, msg):
+
+ class Boolean(bool, models.Choices):
+ pass
+
+ def test_timezone_unsupported(self):
+ msg = "type 'datetime.timezone' is not an acceptable base type"
+ with self.assertRaisesMessage(TypeError, msg):
+
+ class Timezone(datetime.timezone, models.Choices):
+ pass
+
+ def test_uuid_unsupported(self):
+ with self.assertRaises(TypeError):
+
+ class Identifier(uuid.UUID, models.Choices):
+ A = "972ce4eb-a95f-4a56-9339-68c208a76f18"
diff --git a/testbed/django__django/tests/model_fields/__init__.py b/testbed/django__django/tests/model_fields/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testbed/django__django/tests/model_fields/models.py b/testbed/django__django/tests/model_fields/models.py
new file mode 100644
index 0000000000000000000000000000000000000000..424a78746d54d2ea03922acf17d67444c859fbc8
--- /dev/null
+++ b/testbed/django__django/tests/model_fields/models.py
@@ -0,0 +1,471 @@
+import json
+import tempfile
+import uuid
+
+from django.contrib.contenttypes.fields import GenericForeignKey, GenericRelation
+from django.contrib.contenttypes.models import ContentType
+from django.core.files.storage import FileSystemStorage
+from django.core.serializers.json import DjangoJSONEncoder
+from django.db import models
+from django.db.models.fields.files import ImageFieldFile
+from django.utils.translation import gettext_lazy as _
+
+try:
+ from PIL import Image
+except ImportError:
+ Image = None
+
+
+class Foo(models.Model):
+ a = models.CharField(max_length=10)
+ d = models.DecimalField(max_digits=5, decimal_places=3)
+
+
+def get_foo():
+ return Foo.objects.get(id=1).pk
+
+
+class Bar(models.Model):
+ b = models.CharField(max_length=10)
+ a = models.ForeignKey(Foo, models.CASCADE, default=get_foo, related_name="bars")
+
+
+class Whiz(models.Model):
+ CHOICES = (
+ (
+ "Group 1",
+ (
+ (1, "First"),
+ (2, "Second"),
+ ),
+ ),
+ (
+ "Group 2",
+ (
+ (3, "Third"),
+ (4, "Fourth"),
+ ),
+ ),
+ (0, "Other"),
+ (5, _("translated")),
+ )
+ c = models.IntegerField(choices=CHOICES, null=True)
+
+
+class WhizDelayed(models.Model):
+ c = models.IntegerField(choices=(), null=True)
+
+
+# Contrived way of adding choices later.
+WhizDelayed._meta.get_field("c").choices = Whiz.CHOICES
+
+
+class WhizIter(models.Model):
+ c = models.IntegerField(choices=iter(Whiz.CHOICES), null=True)
+
+
+class WhizIterEmpty(models.Model):
+ c = models.CharField(choices=iter(()), blank=True, max_length=1)
+
+
+class Choiceful(models.Model):
+ class Suit(models.IntegerChoices):
+ DIAMOND = 1, "Diamond"
+ SPADE = 2, "Spade"
+ HEART = 3, "Heart"
+ CLUB = 4, "Club"
+
+ no_choices = models.IntegerField(null=True)
+ empty_choices = models.IntegerField(choices=(), null=True)
+ with_choices = models.IntegerField(choices=[(1, "A")], null=True)
+ empty_choices_bool = models.BooleanField(choices=())
+ empty_choices_text = models.TextField(choices=())
+ choices_from_enum = models.IntegerField(choices=Suit)
+
+
+class BigD(models.Model):
+ d = models.DecimalField(max_digits=32, decimal_places=30)
+
+
+class FloatModel(models.Model):
+ size = models.FloatField()
+
+
+class BigS(models.Model):
+ s = models.SlugField(max_length=255)
+
+
+class UnicodeSlugField(models.Model):
+ s = models.SlugField(max_length=255, allow_unicode=True)
+
+
+class AutoModel(models.Model):
+ value = models.AutoField(primary_key=True)
+
+
+class BigAutoModel(models.Model):
+ value = models.BigAutoField(primary_key=True)
+
+
+class SmallAutoModel(models.Model):
+ value = models.SmallAutoField(primary_key=True)
+
+
+class SmallIntegerModel(models.Model):
+ value = models.SmallIntegerField()
+
+
+class IntegerModel(models.Model):
+ value = models.IntegerField()
+
+
+class BigIntegerModel(models.Model):
+ value = models.BigIntegerField()
+ null_value = models.BigIntegerField(null=True, blank=True)
+
+
+class PositiveBigIntegerModel(models.Model):
+ value = models.PositiveBigIntegerField()
+
+
+class PositiveSmallIntegerModel(models.Model):
+ value = models.PositiveSmallIntegerField()
+
+
+class PositiveIntegerModel(models.Model):
+ value = models.PositiveIntegerField()
+
+
+class Post(models.Model):
+ title = models.CharField(max_length=100)
+ body = models.TextField()
+
+
+class NullBooleanModel(models.Model):
+ nbfield = models.BooleanField(null=True, blank=True)
+
+
+class BooleanModel(models.Model):
+ bfield = models.BooleanField()
+
+
+class DateTimeModel(models.Model):
+ d = models.DateField()
+ dt = models.DateTimeField()
+ t = models.TimeField()
+
+
+class DurationModel(models.Model):
+ field = models.DurationField()
+
+
+class NullDurationModel(models.Model):
+ field = models.DurationField(null=True)
+
+
+class PrimaryKeyCharModel(models.Model):
+ string = models.CharField(max_length=10, primary_key=True)
+
+
+class FksToBooleans(models.Model):
+ """Model with FKs to models with {Null,}BooleanField's, #15040"""
+
+ bf = models.ForeignKey(BooleanModel, models.CASCADE)
+ nbf = models.ForeignKey(NullBooleanModel, models.CASCADE)
+
+
+class FkToChar(models.Model):
+ """Model with FK to a model with a CharField primary key, #19299"""
+
+ out = models.ForeignKey(PrimaryKeyCharModel, models.CASCADE)
+
+
+class RenamedField(models.Model):
+ modelname = models.IntegerField(name="fieldname", choices=((1, "One"),))
+
+
+class VerboseNameField(models.Model):
+ id = models.AutoField("verbose pk", primary_key=True)
+ field1 = models.BigIntegerField("verbose field1")
+ field2 = models.BooleanField("verbose field2", default=False)
+ field3 = models.CharField("verbose field3", max_length=10)
+ field4 = models.DateField("verbose field4")
+ field5 = models.DateTimeField("verbose field5")
+ field6 = models.DecimalField("verbose field6", max_digits=6, decimal_places=1)
+ field7 = models.EmailField("verbose field7")
+ field8 = models.FileField("verbose field8", upload_to="unused")
+ field9 = models.FilePathField("verbose field9")
+ field10 = models.FloatField("verbose field10")
+ # Don't want to depend on Pillow in this test
+ # field_image = models.ImageField("verbose field")
+ field11 = models.IntegerField("verbose field11")
+ field12 = models.GenericIPAddressField("verbose field12", protocol="ipv4")
+ field13 = models.PositiveIntegerField("verbose field13")
+ field14 = models.PositiveSmallIntegerField("verbose field14")
+ field15 = models.SlugField("verbose field15")
+ field16 = models.SmallIntegerField("verbose field16")
+ field17 = models.TextField("verbose field17")
+ field18 = models.TimeField("verbose field18")
+ field19 = models.URLField("verbose field19")
+ field20 = models.UUIDField("verbose field20")
+ field21 = models.DurationField("verbose field21")
+
+
+class GenericIPAddress(models.Model):
+ ip = models.GenericIPAddressField(null=True, protocol="ipv4")
+
+
+###############################################################################
+# These models aren't used in any test, just here to ensure they validate
+# successfully.
+
+
+# See ticket #16570.
+class DecimalLessThanOne(models.Model):
+ d = models.DecimalField(max_digits=3, decimal_places=3)
+
+
+# See ticket #18389.
+class FieldClassAttributeModel(models.Model):
+ field_class = models.CharField
+
+
+###############################################################################
+
+
+class DataModel(models.Model):
+ short_data = models.BinaryField(max_length=10, default=b"\x08")
+ data = models.BinaryField()
+
+
+###############################################################################
+# FileField
+
+
+class Document(models.Model):
+ myfile = models.FileField(upload_to="unused", unique=True)
+
+
+###############################################################################
+# ImageField
+
+# If Pillow available, do these tests.
+if Image:
+
+ class TestImageFieldFile(ImageFieldFile):
+ """
+ Custom Field File class that records whether or not the underlying file
+ was opened.
+ """
+
+ def __init__(self, *args, **kwargs):
+ self.was_opened = False
+ super().__init__(*args, **kwargs)
+
+ def open(self):
+ self.was_opened = True
+ super().open()
+
+ class TestImageField(models.ImageField):
+ attr_class = TestImageFieldFile
+
+ # Set up a temp directory for file storage.
+ temp_storage_dir = tempfile.mkdtemp()
+ temp_storage = FileSystemStorage(temp_storage_dir)
+
+ class Person(models.Model):
+ """
+ Model that defines an ImageField with no dimension fields.
+ """
+
+ name = models.CharField(max_length=50)
+ mugshot = TestImageField(storage=temp_storage, upload_to="tests")
+
+ class AbstractPersonWithHeight(models.Model):
+ """
+ Abstract model that defines an ImageField with only one dimension field
+ to make sure the dimension update is correctly run on concrete subclass
+ instance post-initialization.
+ """
+
+ mugshot = TestImageField(
+ storage=temp_storage, upload_to="tests", height_field="mugshot_height"
+ )
+ mugshot_height = models.PositiveSmallIntegerField()
+
+ class Meta:
+ abstract = True
+
+ class PersonWithHeight(AbstractPersonWithHeight):
+ """
+ Concrete model that subclass an abstract one with only on dimension
+ field.
+ """
+
+ name = models.CharField(max_length=50)
+
+ class PersonWithHeightAndWidth(models.Model):
+ """
+ Model that defines height and width fields after the ImageField.
+ """
+
+ name = models.CharField(max_length=50)
+ mugshot = TestImageField(
+ storage=temp_storage,
+ upload_to="tests",
+ height_field="mugshot_height",
+ width_field="mugshot_width",
+ )
+ mugshot_height = models.PositiveSmallIntegerField()
+ mugshot_width = models.PositiveSmallIntegerField()
+
+ class PersonDimensionsFirst(models.Model):
+ """
+ Model that defines height and width fields before the ImageField.
+ """
+
+ name = models.CharField(max_length=50)
+ mugshot_height = models.PositiveSmallIntegerField()
+ mugshot_width = models.PositiveSmallIntegerField()
+ mugshot = TestImageField(
+ storage=temp_storage,
+ upload_to="tests",
+ height_field="mugshot_height",
+ width_field="mugshot_width",
+ )
+
+ class PersonTwoImages(models.Model):
+ """
+ Model that:
+ * Defines two ImageFields
+ * Defines the height/width fields before the ImageFields
+ * Has a nullable ImageField
+ """
+
+ name = models.CharField(max_length=50)
+ mugshot_height = models.PositiveSmallIntegerField()
+ mugshot_width = models.PositiveSmallIntegerField()
+ mugshot = TestImageField(
+ storage=temp_storage,
+ upload_to="tests",
+ height_field="mugshot_height",
+ width_field="mugshot_width",
+ )
+ headshot_height = models.PositiveSmallIntegerField(blank=True, null=True)
+ headshot_width = models.PositiveSmallIntegerField(blank=True, null=True)
+ headshot = TestImageField(
+ blank=True,
+ null=True,
+ storage=temp_storage,
+ upload_to="tests",
+ height_field="headshot_height",
+ width_field="headshot_width",
+ )
+
+
+class CustomJSONDecoder(json.JSONDecoder):
+ def __init__(self, object_hook=None, *args, **kwargs):
+ return super().__init__(object_hook=self.as_uuid, *args, **kwargs)
+
+ def as_uuid(self, dct):
+ if "uuid" in dct:
+ dct["uuid"] = uuid.UUID(dct["uuid"])
+ return dct
+
+
+class JSONModel(models.Model):
+ value = models.JSONField()
+
+ class Meta:
+ required_db_features = {"supports_json_field"}
+
+
+class NullableJSONModel(models.Model):
+ value = models.JSONField(blank=True, null=True)
+ value_custom = models.JSONField(
+ encoder=DjangoJSONEncoder,
+ decoder=CustomJSONDecoder,
+ null=True,
+ )
+
+ class Meta:
+ required_db_features = {"supports_json_field"}
+
+
+class RelatedJSONModel(models.Model):
+ value = models.JSONField()
+ json_model = models.ForeignKey(NullableJSONModel, models.CASCADE)
+
+ class Meta:
+ required_db_features = {"supports_json_field"}
+
+
+class AllFieldsModel(models.Model):
+ big_integer = models.BigIntegerField()
+ binary = models.BinaryField()
+ boolean = models.BooleanField(default=False)
+ char = models.CharField(max_length=10)
+ date = models.DateField()
+ datetime = models.DateTimeField()
+ decimal = models.DecimalField(decimal_places=2, max_digits=2)
+ duration = models.DurationField()
+ email = models.EmailField()
+ file_path = models.FilePathField()
+ floatf = models.FloatField()
+ integer = models.IntegerField()
+ generic_ip = models.GenericIPAddressField()
+ positive_integer = models.PositiveIntegerField()
+ positive_small_integer = models.PositiveSmallIntegerField()
+ slug = models.SlugField()
+ small_integer = models.SmallIntegerField()
+ text = models.TextField()
+ time = models.TimeField()
+ url = models.URLField()
+ uuid = models.UUIDField()
+
+ fo = models.ForeignObject(
+ "self",
+ on_delete=models.CASCADE,
+ from_fields=["positive_integer"],
+ to_fields=["id"],
+ related_name="reverse",
+ )
+ fk = models.ForeignKey("self", models.CASCADE, related_name="reverse2")
+ m2m = models.ManyToManyField("self")
+ oto = models.OneToOneField("self", models.CASCADE)
+
+ object_id = models.PositiveIntegerField()
+ content_type = models.ForeignKey(ContentType, models.CASCADE)
+ gfk = GenericForeignKey()
+ gr = GenericRelation(DataModel)
+
+
+class ManyToMany(models.Model):
+ m2m = models.ManyToManyField("self")
+
+
+###############################################################################
+
+
+class UUIDModel(models.Model):
+ field = models.UUIDField()
+
+
+class NullableUUIDModel(models.Model):
+ field = models.UUIDField(blank=True, null=True)
+
+
+class PrimaryKeyUUIDModel(models.Model):
+ id = models.UUIDField(primary_key=True, default=uuid.uuid4)
+
+
+class RelatedToUUIDModel(models.Model):
+ uuid_fk = models.ForeignKey("PrimaryKeyUUIDModel", models.CASCADE)
+
+
+class UUIDChild(PrimaryKeyUUIDModel):
+ pass
+
+
+class UUIDGrandchild(UUIDChild):
+ pass
diff --git a/testbed/django__django/tests/model_fields/test_autofield.py b/testbed/django__django/tests/model_fields/test_autofield.py
new file mode 100644
index 0000000000000000000000000000000000000000..d2fe5d61254cbc9129a55e7673b345fbfa0b80ee
--- /dev/null
+++ b/testbed/django__django/tests/model_fields/test_autofield.py
@@ -0,0 +1,48 @@
+from django.db import models
+from django.test import SimpleTestCase
+
+from .models import AutoModel, BigAutoModel, SmallAutoModel
+from .test_integerfield import (
+ BigIntegerFieldTests,
+ IntegerFieldTests,
+ SmallIntegerFieldTests,
+)
+
+
+class AutoFieldTests(IntegerFieldTests):
+ model = AutoModel
+ rel_db_type_class = models.IntegerField
+
+
+class BigAutoFieldTests(BigIntegerFieldTests):
+ model = BigAutoModel
+ rel_db_type_class = models.BigIntegerField
+
+
+class SmallAutoFieldTests(SmallIntegerFieldTests):
+ model = SmallAutoModel
+ rel_db_type_class = models.SmallIntegerField
+
+
+class AutoFieldInheritanceTests(SimpleTestCase):
+ def test_isinstance_of_autofield(self):
+ for field in (models.BigAutoField, models.SmallAutoField):
+ with self.subTest(field.__name__):
+ self.assertIsInstance(field(), models.AutoField)
+
+ def test_issubclass_of_autofield(self):
+ class MyBigAutoField(models.BigAutoField):
+ pass
+
+ class MySmallAutoField(models.SmallAutoField):
+ pass
+
+ tests = [
+ MyBigAutoField,
+ MySmallAutoField,
+ models.BigAutoField,
+ models.SmallAutoField,
+ ]
+ for field in tests:
+ with self.subTest(field.__name__):
+ self.assertTrue(issubclass(field, models.AutoField))
diff --git a/testbed/django__django/tests/model_fields/test_binaryfield.py b/testbed/django__django/tests/model_fields/test_binaryfield.py
new file mode 100644
index 0000000000000000000000000000000000000000..05ebce3aab279aa2b6faa6c51b7e2e094b2753a3
--- /dev/null
+++ b/testbed/django__django/tests/model_fields/test_binaryfield.py
@@ -0,0 +1,60 @@
+from django.core.exceptions import ValidationError
+from django.db import models
+from django.test import TestCase
+
+from .models import DataModel
+
+
+class BinaryFieldTests(TestCase):
+ binary_data = b"\x00\x46\xFE"
+
+ def test_set_and_retrieve(self):
+ data_set = (
+ self.binary_data,
+ bytearray(self.binary_data),
+ memoryview(self.binary_data),
+ )
+ for bdata in data_set:
+ with self.subTest(data=repr(bdata)):
+ dm = DataModel(data=bdata)
+ dm.save()
+ dm = DataModel.objects.get(pk=dm.pk)
+ self.assertEqual(bytes(dm.data), bytes(bdata))
+ # Resave (=update)
+ dm.save()
+ dm = DataModel.objects.get(pk=dm.pk)
+ self.assertEqual(bytes(dm.data), bytes(bdata))
+ # Test default value
+ self.assertEqual(bytes(dm.short_data), b"\x08")
+
+ def test_max_length(self):
+ dm = DataModel(short_data=self.binary_data * 4)
+ with self.assertRaises(ValidationError):
+ dm.full_clean()
+
+ def test_editable(self):
+ field = models.BinaryField()
+ self.assertIs(field.editable, False)
+ field = models.BinaryField(editable=True)
+ self.assertIs(field.editable, True)
+ field = models.BinaryField(editable=False)
+ self.assertIs(field.editable, False)
+
+ def test_filter(self):
+ dm = DataModel.objects.create(data=self.binary_data)
+ DataModel.objects.create(data=b"\xef\xbb\xbf")
+ self.assertSequenceEqual(DataModel.objects.filter(data=self.binary_data), [dm])
+
+ def test_filter_bytearray(self):
+ dm = DataModel.objects.create(data=self.binary_data)
+ DataModel.objects.create(data=b"\xef\xbb\xbf")
+ self.assertSequenceEqual(
+ DataModel.objects.filter(data=bytearray(self.binary_data)), [dm]
+ )
+
+ def test_filter_memoryview(self):
+ dm = DataModel.objects.create(data=self.binary_data)
+ DataModel.objects.create(data=b"\xef\xbb\xbf")
+ self.assertSequenceEqual(
+ DataModel.objects.filter(data=memoryview(self.binary_data)), [dm]
+ )
diff --git a/testbed/django__django/tests/model_fields/test_booleanfield.py b/testbed/django__django/tests/model_fields/test_booleanfield.py
new file mode 100644
index 0000000000000000000000000000000000000000..30eb009eb7d239bcabd3df78fa431db4d9df0a5e
--- /dev/null
+++ b/testbed/django__django/tests/model_fields/test_booleanfield.py
@@ -0,0 +1,127 @@
+from django import forms
+from django.core.exceptions import ValidationError
+from django.db import IntegrityError, models, transaction
+from django.test import SimpleTestCase, TestCase
+
+from .models import BooleanModel, FksToBooleans, NullBooleanModel
+
+
+class BooleanFieldTests(TestCase):
+ def _test_get_prep_value(self, f):
+ self.assertIs(f.get_prep_value(True), True)
+ self.assertIs(f.get_prep_value("1"), True)
+ self.assertIs(f.get_prep_value(1), True)
+ self.assertIs(f.get_prep_value(False), False)
+ self.assertIs(f.get_prep_value("0"), False)
+ self.assertIs(f.get_prep_value(0), False)
+ self.assertIsNone(f.get_prep_value(None))
+
+ def _test_to_python(self, f):
+ self.assertIs(f.to_python(1), True)
+ self.assertIs(f.to_python(0), False)
+
+ def test_booleanfield_get_prep_value(self):
+ self._test_get_prep_value(models.BooleanField())
+
+ def test_nullbooleanfield_get_prep_value(self):
+ self._test_get_prep_value(models.BooleanField(null=True))
+
+ def test_booleanfield_to_python(self):
+ self._test_to_python(models.BooleanField())
+
+ def test_nullbooleanfield_to_python(self):
+ self._test_to_python(models.BooleanField(null=True))
+
+ def test_booleanfield_choices_blank(self):
+ """
+ BooleanField with choices and defaults doesn't generate a formfield
+ with the blank option (#9640, #10549).
+ """
+ choices = [(1, "Si"), (2, "No")]
+ f = models.BooleanField(choices=choices, default=1, null=False)
+ self.assertEqual(f.formfield().choices, choices)
+
+ def test_booleanfield_choices_blank_desired(self):
+ """
+ BooleanField with choices and no default should generated a formfield
+ with the blank option.
+ """
+ choices = [(1, "Si"), (2, "No")]
+ f = models.BooleanField(choices=choices)
+ self.assertEqual(f.formfield().choices, [("", "---------")] + choices)
+
+ def test_nullbooleanfield_formfield(self):
+ f = models.BooleanField(null=True)
+ self.assertIsInstance(f.formfield(), forms.NullBooleanField)
+
+ def test_return_type(self):
+ b = BooleanModel.objects.create(bfield=True)
+ b.refresh_from_db()
+ self.assertIs(b.bfield, True)
+
+ b2 = BooleanModel.objects.create(bfield=False)
+ b2.refresh_from_db()
+ self.assertIs(b2.bfield, False)
+
+ b3 = NullBooleanModel.objects.create(nbfield=True)
+ b3.refresh_from_db()
+ self.assertIs(b3.nbfield, True)
+
+ b4 = NullBooleanModel.objects.create(nbfield=False)
+ b4.refresh_from_db()
+ self.assertIs(b4.nbfield, False)
+
+ def test_select_related(self):
+ """
+ Boolean fields retrieved via select_related() should return booleans.
+ """
+ bmt = BooleanModel.objects.create(bfield=True)
+ bmf = BooleanModel.objects.create(bfield=False)
+ nbmt = NullBooleanModel.objects.create(nbfield=True)
+ nbmf = NullBooleanModel.objects.create(nbfield=False)
+ m1 = FksToBooleans.objects.create(bf=bmt, nbf=nbmt)
+ m2 = FksToBooleans.objects.create(bf=bmf, nbf=nbmf)
+
+ # select_related('fk_field_name')
+ ma = FksToBooleans.objects.select_related("bf").get(pk=m1.id)
+ self.assertIs(ma.bf.bfield, True)
+ self.assertIs(ma.nbf.nbfield, True)
+
+ # select_related()
+ mb = FksToBooleans.objects.select_related().get(pk=m1.id)
+ mc = FksToBooleans.objects.select_related().get(pk=m2.id)
+ self.assertIs(mb.bf.bfield, True)
+ self.assertIs(mb.nbf.nbfield, True)
+ self.assertIs(mc.bf.bfield, False)
+ self.assertIs(mc.nbf.nbfield, False)
+
+ def test_null_default(self):
+ """
+ A BooleanField defaults to None, which isn't a valid value (#15124).
+ """
+ boolean_field = BooleanModel._meta.get_field("bfield")
+ self.assertFalse(boolean_field.has_default())
+ b = BooleanModel()
+ self.assertIsNone(b.bfield)
+ with transaction.atomic():
+ with self.assertRaises(IntegrityError):
+ b.save()
+
+ nb = NullBooleanModel()
+ self.assertIsNone(nb.nbfield)
+ nb.save() # no error
+
+
+class ValidationTest(SimpleTestCase):
+ def test_boolean_field_doesnt_accept_empty_input(self):
+ f = models.BooleanField()
+ with self.assertRaises(ValidationError):
+ f.clean(None, None)
+
+ def test_nullbooleanfield_blank(self):
+ """
+ NullBooleanField shouldn't throw a validation error when given a value
+ of None.
+ """
+ nullboolean = NullBooleanModel(nbfield=None)
+ nullboolean.full_clean()
diff --git a/testbed/django__django/tests/model_fields/test_charfield.py b/testbed/django__django/tests/model_fields/test_charfield.py
new file mode 100644
index 0000000000000000000000000000000000000000..782158d210e39327ccf30c925807376aa9860f66
--- /dev/null
+++ b/testbed/django__django/tests/model_fields/test_charfield.py
@@ -0,0 +1,91 @@
+from django.core.exceptions import ValidationError
+from django.db import models
+from django.test import SimpleTestCase, TestCase
+
+from .models import Post
+
+
+class TestCharField(TestCase):
+ def test_max_length_passed_to_formfield(self):
+ """
+ CharField passes its max_length attribute to form fields created using
+ the formfield() method.
+ """
+ cf1 = models.CharField()
+ cf2 = models.CharField(max_length=1234)
+ self.assertIsNone(cf1.formfield().max_length)
+ self.assertEqual(1234, cf2.formfield().max_length)
+
+ def test_lookup_integer_in_charfield(self):
+ self.assertEqual(Post.objects.filter(title=9).count(), 0)
+
+ def test_emoji(self):
+ p = Post.objects.create(title="Smile 😀", body="Whatever.")
+ p.refresh_from_db()
+ self.assertEqual(p.title, "Smile 😀")
+
+ def test_assignment_from_choice_enum(self):
+ class Event(models.TextChoices):
+ C = "Carnival!"
+ F = "Festival!"
+
+ p1 = Post.objects.create(title=Event.C, body=Event.F)
+ p1.refresh_from_db()
+ self.assertEqual(p1.title, "Carnival!")
+ self.assertEqual(p1.body, "Festival!")
+ self.assertEqual(p1.title, Event.C)
+ self.assertEqual(p1.body, Event.F)
+ p2 = Post.objects.get(title="Carnival!")
+ self.assertEqual(p1, p2)
+ self.assertEqual(p2.title, Event.C)
+
+
+class TestMethods(SimpleTestCase):
+ def test_deconstruct(self):
+ field = models.CharField()
+ *_, kwargs = field.deconstruct()
+ self.assertEqual(kwargs, {})
+ field = models.CharField(db_collation="utf8_esperanto_ci")
+ *_, kwargs = field.deconstruct()
+ self.assertEqual(kwargs, {"db_collation": "utf8_esperanto_ci"})
+
+
+class ValidationTests(SimpleTestCase):
+ class Choices(models.TextChoices):
+ C = "c", "C"
+
+ def test_charfield_raises_error_on_empty_string(self):
+ f = models.CharField()
+ msg = "This field cannot be blank."
+ with self.assertRaisesMessage(ValidationError, msg):
+ f.clean("", None)
+
+ def test_charfield_cleans_empty_string_when_blank_true(self):
+ f = models.CharField(blank=True)
+ self.assertEqual("", f.clean("", None))
+
+ def test_charfield_with_choices_cleans_valid_choice(self):
+ f = models.CharField(max_length=1, choices=[("a", "A"), ("b", "B")])
+ self.assertEqual("a", f.clean("a", None))
+
+ def test_charfield_with_choices_raises_error_on_invalid_choice(self):
+ f = models.CharField(choices=[("a", "A"), ("b", "B")])
+ msg = "Value 'not a' is not a valid choice."
+ with self.assertRaisesMessage(ValidationError, msg):
+ f.clean("not a", None)
+
+ def test_enum_choices_cleans_valid_string(self):
+ f = models.CharField(choices=self.Choices, max_length=1)
+ self.assertEqual(f.clean("c", None), "c")
+
+ def test_enum_choices_invalid_input(self):
+ f = models.CharField(choices=self.Choices, max_length=1)
+ msg = "Value 'a' is not a valid choice."
+ with self.assertRaisesMessage(ValidationError, msg):
+ f.clean("a", None)
+
+ def test_charfield_raises_error_on_empty_input(self):
+ f = models.CharField(null=False)
+ msg = "This field cannot be null."
+ with self.assertRaisesMessage(ValidationError, msg):
+ f.clean(None, None)
diff --git a/testbed/django__django/tests/model_fields/test_datetimefield.py b/testbed/django__django/tests/model_fields/test_datetimefield.py
new file mode 100644
index 0000000000000000000000000000000000000000..26efd481e15fecaadf3b8e80b0d60fedb8674ebb
--- /dev/null
+++ b/testbed/django__django/tests/model_fields/test_datetimefield.py
@@ -0,0 +1,81 @@
+import datetime
+
+from django.db import models
+from django.test import SimpleTestCase, TestCase, override_settings, skipUnlessDBFeature
+from django.test.utils import requires_tz_support
+from django.utils import timezone
+
+from .models import DateTimeModel
+
+
+class DateTimeFieldTests(TestCase):
+ def test_datetimefield_to_python_microseconds(self):
+ """DateTimeField.to_python() supports microseconds."""
+ f = models.DateTimeField()
+ self.assertEqual(
+ f.to_python("2001-01-02 03:04:05.000006"),
+ datetime.datetime(2001, 1, 2, 3, 4, 5, 6),
+ )
+ self.assertEqual(
+ f.to_python("2001-01-02 03:04:05.999999"),
+ datetime.datetime(2001, 1, 2, 3, 4, 5, 999999),
+ )
+
+ def test_timefield_to_python_microseconds(self):
+ """TimeField.to_python() supports microseconds."""
+ f = models.TimeField()
+ self.assertEqual(f.to_python("01:02:03.000004"), datetime.time(1, 2, 3, 4))
+ self.assertEqual(f.to_python("01:02:03.999999"), datetime.time(1, 2, 3, 999999))
+
+ def test_datetimes_save_completely(self):
+ dat = datetime.date(2014, 3, 12)
+ datetim = datetime.datetime(2014, 3, 12, 21, 22, 23, 240000)
+ tim = datetime.time(21, 22, 23, 240000)
+ DateTimeModel.objects.create(d=dat, dt=datetim, t=tim)
+ obj = DateTimeModel.objects.first()
+ self.assertTrue(obj)
+ self.assertEqual(obj.d, dat)
+ self.assertEqual(obj.dt, datetim)
+ self.assertEqual(obj.t, tim)
+
+ @override_settings(USE_TZ=False)
+ def test_lookup_date_without_use_tz(self):
+ d = datetime.date(2014, 3, 12)
+ dt1 = datetime.datetime(2014, 3, 12, 21, 22, 23, 240000)
+ dt2 = datetime.datetime(2014, 3, 11, 21, 22, 23, 240000)
+ t = datetime.time(21, 22, 23, 240000)
+ m = DateTimeModel.objects.create(d=d, dt=dt1, t=t)
+ # Other model with different datetime.
+ DateTimeModel.objects.create(d=d, dt=dt2, t=t)
+ self.assertEqual(m, DateTimeModel.objects.get(dt__date=d))
+
+ @requires_tz_support
+ @skipUnlessDBFeature("has_zoneinfo_database")
+ @override_settings(USE_TZ=True, TIME_ZONE="America/Vancouver")
+ def test_lookup_date_with_use_tz(self):
+ d = datetime.date(2014, 3, 12)
+ # The following is equivalent to UTC 2014-03-12 18:34:23.24000.
+ dt1 = datetime.datetime(
+ 2014, 3, 12, 10, 22, 23, 240000, tzinfo=timezone.get_current_timezone()
+ )
+ # The following is equivalent to UTC 2014-03-13 05:34:23.24000.
+ dt2 = datetime.datetime(
+ 2014, 3, 12, 21, 22, 23, 240000, tzinfo=timezone.get_current_timezone()
+ )
+ t = datetime.time(21, 22, 23, 240000)
+ m1 = DateTimeModel.objects.create(d=d, dt=dt1, t=t)
+ m2 = DateTimeModel.objects.create(d=d, dt=dt2, t=t)
+ # In Vancouver, we expect both results.
+ self.assertCountEqual(
+ DateTimeModel.objects.filter(dt__date=d),
+ [m1, m2],
+ )
+ with self.settings(TIME_ZONE="UTC"):
+ # But in UTC, the __date only matches one of them.
+ self.assertCountEqual(DateTimeModel.objects.filter(dt__date=d), [m1])
+
+
+class ValidationTest(SimpleTestCase):
+ def test_datefield_cleans_date(self):
+ f = models.DateField()
+ self.assertEqual(datetime.date(2008, 10, 10), f.clean("2008-10-10", None))
diff --git a/testbed/django__django/tests/model_fields/test_decimalfield.py b/testbed/django__django/tests/model_fields/test_decimalfield.py
new file mode 100644
index 0000000000000000000000000000000000000000..588bb64a3a122588213ff656a10063f01fff39bc
--- /dev/null
+++ b/testbed/django__django/tests/model_fields/test_decimalfield.py
@@ -0,0 +1,127 @@
+import math
+from decimal import Decimal
+
+from django.core import validators
+from django.core.exceptions import ValidationError
+from django.db import models
+from django.test import TestCase
+
+from .models import BigD, Foo
+
+
+class DecimalFieldTests(TestCase):
+ def test_to_python(self):
+ f = models.DecimalField(max_digits=4, decimal_places=2)
+ self.assertEqual(f.to_python(3), Decimal("3"))
+ self.assertEqual(f.to_python("3.14"), Decimal("3.14"))
+ # to_python() converts floats and honors max_digits.
+ self.assertEqual(f.to_python(3.1415926535897), Decimal("3.142"))
+ self.assertEqual(f.to_python(2.4), Decimal("2.400"))
+ # Uses default rounding of ROUND_HALF_EVEN.
+ self.assertEqual(f.to_python(2.0625), Decimal("2.062"))
+ self.assertEqual(f.to_python(2.1875), Decimal("2.188"))
+
+ def test_invalid_value(self):
+ field = models.DecimalField(max_digits=4, decimal_places=2)
+ msg = "“%s” value must be a decimal number."
+ tests = [
+ (),
+ [],
+ {},
+ set(),
+ object(),
+ complex(),
+ "non-numeric string",
+ b"non-numeric byte-string",
+ ]
+ for value in tests:
+ with self.subTest(value):
+ with self.assertRaisesMessage(ValidationError, msg % (value,)):
+ field.clean(value, None)
+
+ def test_default(self):
+ f = models.DecimalField(default=Decimal("0.00"))
+ self.assertEqual(f.get_default(), Decimal("0.00"))
+
+ def test_get_prep_value(self):
+ f = models.DecimalField(max_digits=5, decimal_places=1)
+ self.assertIsNone(f.get_prep_value(None))
+ self.assertEqual(f.get_prep_value("2.4"), Decimal("2.4"))
+
+ def test_filter_with_strings(self):
+ """
+ Should be able to filter decimal fields using strings (#8023).
+ """
+ foo = Foo.objects.create(a="abc", d=Decimal("12.34"))
+ self.assertEqual(list(Foo.objects.filter(d="12.34")), [foo])
+
+ def test_save_without_float_conversion(self):
+ """
+ Ensure decimals don't go through a corrupting float conversion during
+ save (#5079).
+ """
+ bd = BigD(d="12.9")
+ bd.save()
+ bd = BigD.objects.get(pk=bd.pk)
+ self.assertEqual(bd.d, Decimal("12.9"))
+
+ def test_save_nan_invalid(self):
+ msg = "“nan” value must be a decimal number."
+ for value in [float("nan"), math.nan, "nan"]:
+ with self.subTest(value), self.assertRaisesMessage(ValidationError, msg):
+ BigD.objects.create(d=value)
+
+ def test_save_inf_invalid(self):
+ msg = "“inf” value must be a decimal number."
+ for value in [float("inf"), math.inf, "inf"]:
+ with self.subTest(value), self.assertRaisesMessage(ValidationError, msg):
+ BigD.objects.create(d=value)
+ msg = "“-inf” value must be a decimal number."
+ for value in [float("-inf"), -math.inf, "-inf"]:
+ with self.subTest(value), self.assertRaisesMessage(ValidationError, msg):
+ BigD.objects.create(d=value)
+
+ def test_fetch_from_db_without_float_rounding(self):
+ big_decimal = BigD.objects.create(d=Decimal(".100000000000000000000000000005"))
+ big_decimal.refresh_from_db()
+ self.assertEqual(big_decimal.d, Decimal(".100000000000000000000000000005"))
+
+ def test_lookup_really_big_value(self):
+ """
+ Really big values can be used in a filter statement.
+ """
+ # This should not crash.
+ self.assertSequenceEqual(Foo.objects.filter(d__gte=100000000000), [])
+
+ def test_lookup_decimal_larger_than_max_digits(self):
+ self.assertSequenceEqual(Foo.objects.filter(d__lte=Decimal("123456")), [])
+
+ def test_max_digits_validation(self):
+ field = models.DecimalField(max_digits=2)
+ expected_message = validators.DecimalValidator.messages["max_digits"] % {
+ "max": 2
+ }
+ with self.assertRaisesMessage(ValidationError, expected_message):
+ field.clean(100, None)
+
+ def test_max_decimal_places_validation(self):
+ field = models.DecimalField(decimal_places=1)
+ expected_message = validators.DecimalValidator.messages[
+ "max_decimal_places"
+ ] % {"max": 1}
+ with self.assertRaisesMessage(ValidationError, expected_message):
+ field.clean(Decimal("0.99"), None)
+
+ def test_max_whole_digits_validation(self):
+ field = models.DecimalField(max_digits=3, decimal_places=1)
+ expected_message = validators.DecimalValidator.messages["max_whole_digits"] % {
+ "max": 2
+ }
+ with self.assertRaisesMessage(ValidationError, expected_message):
+ field.clean(Decimal("999"), None)
+
+ def test_roundtrip_with_trailing_zeros(self):
+ """Trailing zeros in the fractional part aren't truncated."""
+ obj = Foo.objects.create(a="bar", d=Decimal("8.320"))
+ obj.refresh_from_db()
+ self.assertEqual(obj.d.compare_total(Decimal("8.320")), Decimal("0"))
diff --git a/testbed/django__django/tests/model_fields/test_durationfield.py b/testbed/django__django/tests/model_fields/test_durationfield.py
new file mode 100644
index 0000000000000000000000000000000000000000..c93b81ecf0174a522313619f36b30c8f2cd4d3bd
--- /dev/null
+++ b/testbed/django__django/tests/model_fields/test_durationfield.py
@@ -0,0 +1,87 @@
+import datetime
+import json
+
+from django import forms
+from django.core import exceptions, serializers
+from django.db import models
+from django.test import SimpleTestCase, TestCase
+
+from .models import DurationModel, NullDurationModel
+
+
+class TestSaveLoad(TestCase):
+ def test_simple_roundtrip(self):
+ duration = datetime.timedelta(microseconds=8999999999999999)
+ DurationModel.objects.create(field=duration)
+ loaded = DurationModel.objects.get()
+ self.assertEqual(loaded.field, duration)
+
+ def test_create_empty(self):
+ NullDurationModel.objects.create()
+ loaded = NullDurationModel.objects.get()
+ self.assertIsNone(loaded.field)
+
+ def test_fractional_seconds(self):
+ value = datetime.timedelta(seconds=2.05)
+ d = DurationModel.objects.create(field=value)
+ d.refresh_from_db()
+ self.assertEqual(d.field, value)
+
+
+class TestQuerying(TestCase):
+ @classmethod
+ def setUpTestData(cls):
+ cls.objs = [
+ DurationModel.objects.create(field=datetime.timedelta(days=1)),
+ DurationModel.objects.create(field=datetime.timedelta(seconds=1)),
+ DurationModel.objects.create(field=datetime.timedelta(seconds=-1)),
+ ]
+
+ def test_exact(self):
+ self.assertSequenceEqual(
+ DurationModel.objects.filter(field=datetime.timedelta(days=1)),
+ [self.objs[0]],
+ )
+
+ def test_gt(self):
+ self.assertCountEqual(
+ DurationModel.objects.filter(field__gt=datetime.timedelta(days=0)),
+ [self.objs[0], self.objs[1]],
+ )
+
+
+class TestSerialization(SimpleTestCase):
+ test_data = (
+ '[{"fields": {"field": "1 01:00:00"}, "model": "model_fields.durationmodel", '
+ '"pk": null}]'
+ )
+
+ def test_dumping(self):
+ instance = DurationModel(field=datetime.timedelta(days=1, hours=1))
+ data = serializers.serialize("json", [instance])
+ self.assertEqual(json.loads(data), json.loads(self.test_data))
+
+ def test_loading(self):
+ instance = list(serializers.deserialize("json", self.test_data))[0].object
+ self.assertEqual(instance.field, datetime.timedelta(days=1, hours=1))
+
+
+class TestValidation(SimpleTestCase):
+ def test_invalid_string(self):
+ field = models.DurationField()
+ with self.assertRaises(exceptions.ValidationError) as cm:
+ field.clean("not a datetime", None)
+ self.assertEqual(cm.exception.code, "invalid")
+ self.assertEqual(
+ cm.exception.message % cm.exception.params,
+ "“not a datetime” value has an invalid format. "
+ "It must be in [DD] [[HH:]MM:]ss[.uuuuuu] format.",
+ )
+
+
+class TestFormField(SimpleTestCase):
+ # Tests for forms.DurationField are in the forms_tests app.
+
+ def test_formfield(self):
+ field = models.DurationField()
+ self.assertIsInstance(field.formfield(), forms.DurationField)
diff --git a/testbed/django__django/tests/model_fields/test_filefield.py b/testbed/django__django/tests/model_fields/test_filefield.py
new file mode 100644
index 0000000000000000000000000000000000000000..2259c1e480d74926cbf2a2a554b453c3c93bcb21
--- /dev/null
+++ b/testbed/django__django/tests/model_fields/test_filefield.py
@@ -0,0 +1,191 @@
+import os
+import pickle
+import sys
+import tempfile
+import unittest
+from pathlib import Path
+
+from django.core.exceptions import SuspiciousFileOperation
+from django.core.files import File, temp
+from django.core.files.base import ContentFile
+from django.core.files.uploadedfile import TemporaryUploadedFile
+from django.db import IntegrityError, models
+from django.test import TestCase, override_settings
+from django.test.utils import isolate_apps
+
+from .models import Document
+
+
+class FileFieldTests(TestCase):
+ def test_clearable(self):
+ """
+ FileField.save_form_data() will clear its instance attribute value if
+ passed False.
+ """
+ d = Document(myfile="something.txt")
+ self.assertEqual(d.myfile, "something.txt")
+ field = d._meta.get_field("myfile")
+ field.save_form_data(d, False)
+ self.assertEqual(d.myfile, "")
+
+ def test_unchanged(self):
+ """
+ FileField.save_form_data() considers None to mean "no change" rather
+ than "clear".
+ """
+ d = Document(myfile="something.txt")
+ self.assertEqual(d.myfile, "something.txt")
+ field = d._meta.get_field("myfile")
+ field.save_form_data(d, None)
+ self.assertEqual(d.myfile, "something.txt")
+
+ def test_changed(self):
+ """
+ FileField.save_form_data(), if passed a truthy value, updates its
+ instance attribute.
+ """
+ d = Document(myfile="something.txt")
+ self.assertEqual(d.myfile, "something.txt")
+ field = d._meta.get_field("myfile")
+ field.save_form_data(d, "else.txt")
+ self.assertEqual(d.myfile, "else.txt")
+
+ def test_delete_when_file_unset(self):
+ """
+ Calling delete on an unset FileField should not call the file deletion
+ process, but fail silently (#20660).
+ """
+ d = Document()
+ d.myfile.delete()
+
+ def test_refresh_from_db(self):
+ d = Document.objects.create(myfile="something.txt")
+ d.refresh_from_db()
+ self.assertIs(d.myfile.instance, d)
+
+ @unittest.skipIf(sys.platform == "win32", "Crashes with OSError on Windows.")
+ def test_save_without_name(self):
+ with tempfile.NamedTemporaryFile(suffix=".txt") as tmp:
+ document = Document.objects.create(myfile="something.txt")
+ document.myfile = File(tmp)
+ msg = f"Detected path traversal attempt in '{tmp.name}'"
+ with self.assertRaisesMessage(SuspiciousFileOperation, msg):
+ document.save()
+
+ def test_defer(self):
+ Document.objects.create(myfile="something.txt")
+ self.assertEqual(Document.objects.defer("myfile")[0].myfile, "something.txt")
+
+ def test_unique_when_same_filename(self):
+ """
+ A FileField with unique=True shouldn't allow two instances with the
+ same name to be saved.
+ """
+ Document.objects.create(myfile="something.txt")
+ with self.assertRaises(IntegrityError):
+ Document.objects.create(myfile="something.txt")
+
+ @unittest.skipIf(
+ sys.platform == "win32", "Windows doesn't support moving open files."
+ )
+ # The file's source and destination must be on the same filesystem.
+ @override_settings(MEDIA_ROOT=temp.gettempdir())
+ def test_move_temporary_file(self):
+ """
+ The temporary uploaded file is moved rather than copied to the
+ destination.
+ """
+ with TemporaryUploadedFile(
+ "something.txt", "text/plain", 0, "UTF-8"
+ ) as tmp_file:
+ tmp_file_path = tmp_file.temporary_file_path()
+ Document.objects.create(myfile=tmp_file)
+ self.assertFalse(
+ os.path.exists(tmp_file_path), "Temporary file still exists"
+ )
+
+ def test_open_returns_self(self):
+ """
+ FieldField.open() returns self so it can be used as a context manager.
+ """
+ d = Document.objects.create(myfile="something.txt")
+ # Replace the FileField's file with an in-memory ContentFile, so that
+ # open() doesn't write to disk.
+ d.myfile.file = ContentFile(b"", name="bla")
+ self.assertEqual(d.myfile, d.myfile.open())
+
+ def test_media_root_pathlib(self):
+ with tempfile.TemporaryDirectory() as tmp_dir:
+ with override_settings(MEDIA_ROOT=Path(tmp_dir)):
+ with TemporaryUploadedFile(
+ "foo.txt", "text/plain", 1, "utf-8"
+ ) as tmp_file:
+ document = Document.objects.create(myfile=tmp_file)
+ self.assertIs(
+ document.myfile.storage.exists(
+ os.path.join("unused", "foo.txt")
+ ),
+ True,
+ )
+
+ def test_pickle(self):
+ with tempfile.TemporaryDirectory() as tmp_dir:
+ with override_settings(MEDIA_ROOT=Path(tmp_dir)):
+ with open(__file__, "rb") as fp:
+ file1 = File(fp, name="test_file.py")
+ document = Document(myfile="test_file.py")
+ document.myfile.save("test_file.py", file1)
+ try:
+ dump = pickle.dumps(document)
+ loaded_document = pickle.loads(dump)
+ self.assertEqual(document.myfile, loaded_document.myfile)
+ self.assertEqual(
+ document.myfile.url,
+ loaded_document.myfile.url,
+ )
+ self.assertEqual(
+ document.myfile.storage,
+ loaded_document.myfile.storage,
+ )
+ self.assertEqual(
+ document.myfile.instance,
+ loaded_document.myfile.instance,
+ )
+ self.assertEqual(
+ document.myfile.field,
+ loaded_document.myfile.field,
+ )
+ myfile_dump = pickle.dumps(document.myfile)
+ loaded_myfile = pickle.loads(myfile_dump)
+ self.assertEqual(document.myfile, loaded_myfile)
+ self.assertEqual(document.myfile.url, loaded_myfile.url)
+ self.assertEqual(
+ document.myfile.storage,
+ loaded_myfile.storage,
+ )
+ self.assertEqual(
+ document.myfile.instance,
+ loaded_myfile.instance,
+ )
+ self.assertEqual(document.myfile.field, loaded_myfile.field)
+ finally:
+ document.myfile.delete()
+
+ @isolate_apps("model_fields")
+ def test_abstract_filefield_model(self):
+ """
+ FileField.model returns the concrete model for fields defined in an
+ abstract model.
+ """
+
+ class AbstractMyDocument(models.Model):
+ myfile = models.FileField(upload_to="unused")
+
+ class Meta:
+ abstract = True
+
+ class MyDocument(AbstractMyDocument):
+ pass
+
+ document = MyDocument(myfile="test_file.py")
+ self.assertEqual(document.myfile.field.model, MyDocument)
diff --git a/testbed/django__django/tests/model_fields/test_floatfield.py b/testbed/django__django/tests/model_fields/test_floatfield.py
new file mode 100644
index 0000000000000000000000000000000000000000..264b5677e9bb0e2751e1a8e0fb8266efd5bc80e5
--- /dev/null
+++ b/testbed/django__django/tests/model_fields/test_floatfield.py
@@ -0,0 +1,49 @@
+from django.db import transaction
+from django.test import TestCase
+
+from .models import FloatModel
+
+
+class TestFloatField(TestCase):
+ def test_float_validates_object(self):
+ instance = FloatModel(size=2.5)
+ # Try setting float field to unsaved object
+ instance.size = instance
+ with transaction.atomic():
+ with self.assertRaises(TypeError):
+ instance.save()
+ # Set value to valid and save
+ instance.size = 2.5
+ instance.save()
+ self.assertTrue(instance.id)
+ # Set field to object on saved instance
+ instance.size = instance
+ msg = (
+ "Tried to update field model_fields.FloatModel.size with a model "
+ "instance, %r. Use a value compatible with FloatField."
+ ) % instance
+ with transaction.atomic():
+ with self.assertRaisesMessage(TypeError, msg):
+ instance.save()
+ # Try setting field to object on retrieved object
+ obj = FloatModel.objects.get(pk=instance.id)
+ obj.size = obj
+ with self.assertRaisesMessage(TypeError, msg):
+ obj.save()
+
+ def test_invalid_value(self):
+ tests = [
+ (TypeError, ()),
+ (TypeError, []),
+ (TypeError, {}),
+ (TypeError, set()),
+ (TypeError, object()),
+ (TypeError, complex()),
+ (ValueError, "non-numeric string"),
+ (ValueError, b"non-numeric byte-string"),
+ ]
+ for exception, value in tests:
+ with self.subTest(value):
+ msg = "Field 'size' expected a number but got %r." % (value,)
+ with self.assertRaisesMessage(exception, msg):
+ FloatModel.objects.create(size=value)
diff --git a/testbed/django__django/tests/model_fields/test_genericipaddressfield.py b/testbed/django__django/tests/model_fields/test_genericipaddressfield.py
new file mode 100644
index 0000000000000000000000000000000000000000..76845238e54ff24a34143b8272341e9885b37aab
--- /dev/null
+++ b/testbed/django__django/tests/model_fields/test_genericipaddressfield.py
@@ -0,0 +1,42 @@
+from django.core.exceptions import ValidationError
+from django.db import models
+from django.test import TestCase
+
+from .models import GenericIPAddress
+
+
+class GenericIPAddressFieldTests(TestCase):
+ def test_genericipaddressfield_formfield_protocol(self):
+ """
+ GenericIPAddressField with a specified protocol does not generate a
+ formfield without a protocol.
+ """
+ model_field = models.GenericIPAddressField(protocol="IPv4")
+ form_field = model_field.formfield()
+ with self.assertRaises(ValidationError):
+ form_field.clean("::1")
+ model_field = models.GenericIPAddressField(protocol="IPv6")
+ form_field = model_field.formfield()
+ with self.assertRaises(ValidationError):
+ form_field.clean("127.0.0.1")
+
+ def test_null_value(self):
+ """
+ Null values should be resolved to None.
+ """
+ GenericIPAddress.objects.create()
+ o = GenericIPAddress.objects.get()
+ self.assertIsNone(o.ip)
+
+ def test_blank_string_saved_as_null(self):
+ o = GenericIPAddress.objects.create(ip="")
+ o.refresh_from_db()
+ self.assertIsNone(o.ip)
+ GenericIPAddress.objects.update(ip="")
+ o.refresh_from_db()
+ self.assertIsNone(o.ip)
+
+ def test_save_load(self):
+ instance = GenericIPAddress.objects.create(ip="::1")
+ loaded = GenericIPAddress.objects.get()
+ self.assertEqual(loaded.ip, instance.ip)
diff --git a/testbed/django__django/tests/model_fields/test_imagefield.py b/testbed/django__django/tests/model_fields/test_imagefield.py
new file mode 100644
index 0000000000000000000000000000000000000000..8bbfee30f254a4028107ccf3da9dceb999af68bc
--- /dev/null
+++ b/testbed/django__django/tests/model_fields/test_imagefield.py
@@ -0,0 +1,478 @@
+import os
+import shutil
+from unittest import skipIf
+
+from django.core.exceptions import ImproperlyConfigured
+from django.core.files import File
+from django.core.files.images import ImageFile
+from django.db.models import signals
+from django.test import TestCase
+from django.test.testcases import SerializeMixin
+
+try:
+ from .models import Image
+except ImproperlyConfigured:
+ Image = None
+
+if Image:
+ from .models import (
+ Person,
+ PersonDimensionsFirst,
+ PersonTwoImages,
+ PersonWithHeight,
+ PersonWithHeightAndWidth,
+ TestImageFieldFile,
+ temp_storage_dir,
+ )
+else:
+ # Pillow not available, create dummy classes (tests will be skipped anyway)
+ class Person:
+ pass
+
+ PersonWithHeight = PersonWithHeightAndWidth = PersonDimensionsFirst = Person
+ PersonTwoImages = Person
+
+
+class ImageFieldTestMixin(SerializeMixin):
+ """
+ Mixin class to provide common functionality to ImageField test classes.
+ """
+
+ lockfile = __file__
+
+ # Person model to use for tests.
+ PersonModel = PersonWithHeightAndWidth
+ # File class to use for file instances.
+ File = ImageFile
+
+ def setUp(self):
+ """
+ Creates a pristine temp directory (or deletes and recreates if it
+ already exists) that the model uses as its storage directory.
+
+ Sets up two ImageFile instances for use in tests.
+ """
+ if os.path.exists(temp_storage_dir):
+ shutil.rmtree(temp_storage_dir)
+ os.mkdir(temp_storage_dir)
+
+ file_path1 = os.path.join(os.path.dirname(__file__), "4x8.png")
+ self.file1 = self.File(open(file_path1, "rb"), name="4x8.png")
+
+ file_path2 = os.path.join(os.path.dirname(__file__), "8x4.png")
+ self.file2 = self.File(open(file_path2, "rb"), name="8x4.png")
+
+ def tearDown(self):
+ """
+ Removes temp directory and all its contents.
+ """
+ self.file1.close()
+ self.file2.close()
+ shutil.rmtree(temp_storage_dir)
+
+ def check_dimensions(self, instance, width, height, field_name="mugshot"):
+ """
+ Asserts that the given width and height values match both the
+ field's height and width attributes and the height and width fields
+ (if defined) the image field is caching to.
+
+ Note, this method will check for dimension fields named by adding
+ "_width" or "_height" to the name of the ImageField. So, the
+ models used in these tests must have their fields named
+ accordingly.
+
+ By default, we check the field named "mugshot", but this can be
+ specified by passing the field_name parameter.
+ """
+ field = getattr(instance, field_name)
+ # Check height/width attributes of field.
+ if width is None and height is None:
+ with self.assertRaises(ValueError):
+ getattr(field, "width")
+ with self.assertRaises(ValueError):
+ getattr(field, "height")
+ else:
+ self.assertEqual(field.width, width)
+ self.assertEqual(field.height, height)
+
+ # Check height/width fields of model, if defined.
+ width_field_name = field_name + "_width"
+ if hasattr(instance, width_field_name):
+ self.assertEqual(getattr(instance, width_field_name), width)
+ height_field_name = field_name + "_height"
+ if hasattr(instance, height_field_name):
+ self.assertEqual(getattr(instance, height_field_name), height)
+
+
+@skipIf(Image is None, "Pillow is required to test ImageField")
+class ImageFieldTests(ImageFieldTestMixin, TestCase):
+ """
+ Tests for ImageField that don't need to be run with each of the
+ different test model classes.
+ """
+
+ def test_equal_notequal_hash(self):
+ """
+ Bug #9786: Ensure '==' and '!=' work correctly.
+ Bug #9508: make sure hash() works as expected (equal items must
+ hash to the same value).
+ """
+ # Create two Persons with different mugshots.
+ p1 = self.PersonModel(name="Joe")
+ p1.mugshot.save("mug", self.file1)
+ p2 = self.PersonModel(name="Bob")
+ p2.mugshot.save("mug", self.file2)
+ self.assertIs(p1.mugshot == p2.mugshot, False)
+ self.assertIs(p1.mugshot != p2.mugshot, True)
+
+ # Test again with an instance fetched from the db.
+ p1_db = self.PersonModel.objects.get(name="Joe")
+ self.assertIs(p1_db.mugshot == p2.mugshot, False)
+ self.assertIs(p1_db.mugshot != p2.mugshot, True)
+
+ # Instance from db should match the local instance.
+ self.assertIs(p1_db.mugshot == p1.mugshot, True)
+ self.assertEqual(hash(p1_db.mugshot), hash(p1.mugshot))
+ self.assertIs(p1_db.mugshot != p1.mugshot, False)
+
+ def test_instantiate_missing(self):
+ """
+ If the underlying file is unavailable, still create instantiate the
+ object without error.
+ """
+ p = self.PersonModel(name="Joan")
+ p.mugshot.save("shot", self.file1)
+ p = self.PersonModel.objects.get(name="Joan")
+ path = p.mugshot.path
+ shutil.move(path, path + ".moved")
+ self.PersonModel.objects.get(name="Joan")
+
+ def test_delete_when_missing(self):
+ """
+ Bug #8175: correctly delete an object where the file no longer
+ exists on the file system.
+ """
+ p = self.PersonModel(name="Fred")
+ p.mugshot.save("shot", self.file1)
+ os.remove(p.mugshot.path)
+ p.delete()
+
+ def test_size_method(self):
+ """
+ Bug #8534: FileField.size should not leave the file open.
+ """
+ p = self.PersonModel(name="Joan")
+ p.mugshot.save("shot", self.file1)
+
+ # Get a "clean" model instance
+ p = self.PersonModel.objects.get(name="Joan")
+ # It won't have an opened file.
+ self.assertIs(p.mugshot.closed, True)
+
+ # After asking for the size, the file should still be closed.
+ p.mugshot.size
+ self.assertIs(p.mugshot.closed, True)
+
+ def test_pickle(self):
+ """
+ ImageField can be pickled, unpickled, and that the image of
+ the unpickled version is the same as the original.
+ """
+ import pickle
+
+ p = Person(name="Joe")
+ p.mugshot.save("mug", self.file1)
+ dump = pickle.dumps(p)
+
+ loaded_p = pickle.loads(dump)
+ self.assertEqual(p.mugshot, loaded_p.mugshot)
+ self.assertEqual(p.mugshot.url, loaded_p.mugshot.url)
+ self.assertEqual(p.mugshot.storage, loaded_p.mugshot.storage)
+ self.assertEqual(p.mugshot.instance, loaded_p.mugshot.instance)
+ self.assertEqual(p.mugshot.field, loaded_p.mugshot.field)
+
+ mugshot_dump = pickle.dumps(p.mugshot)
+ loaded_mugshot = pickle.loads(mugshot_dump)
+ self.assertEqual(p.mugshot, loaded_mugshot)
+ self.assertEqual(p.mugshot.url, loaded_mugshot.url)
+ self.assertEqual(p.mugshot.storage, loaded_mugshot.storage)
+ self.assertEqual(p.mugshot.instance, loaded_mugshot.instance)
+ self.assertEqual(p.mugshot.field, loaded_mugshot.field)
+
+ def test_defer(self):
+ self.PersonModel.objects.create(name="Joe", mugshot=self.file1)
+ with self.assertNumQueries(1):
+ qs = list(self.PersonModel.objects.defer("mugshot"))
+ with self.assertNumQueries(0):
+ self.assertEqual(qs[0].name, "Joe")
+
+
+@skipIf(Image is None, "Pillow is required to test ImageField")
+class ImageFieldTwoDimensionsTests(ImageFieldTestMixin, TestCase):
+ """
+ Tests behavior of an ImageField and its dimensions fields.
+ """
+
+ def test_constructor(self):
+ """
+ Tests assigning an image field through the model's constructor.
+ """
+ p = self.PersonModel(name="Joe", mugshot=self.file1)
+ self.check_dimensions(p, 4, 8)
+ p.save()
+ self.check_dimensions(p, 4, 8)
+
+ def test_image_after_constructor(self):
+ """
+ Tests behavior when image is not passed in constructor.
+ """
+ p = self.PersonModel(name="Joe")
+ # TestImageField value will default to being an instance of its
+ # attr_class, a TestImageFieldFile, with name == None, which will
+ # cause it to evaluate as False.
+ self.assertIsInstance(p.mugshot, TestImageFieldFile)
+ self.assertFalse(p.mugshot)
+
+ # Test setting a fresh created model instance.
+ p = self.PersonModel(name="Joe")
+ p.mugshot = self.file1
+ self.check_dimensions(p, 4, 8)
+
+ def test_create(self):
+ """
+ Tests assigning an image in Manager.create().
+ """
+ p = self.PersonModel.objects.create(name="Joe", mugshot=self.file1)
+ self.check_dimensions(p, 4, 8)
+
+ def test_default_value(self):
+ """
+ The default value for an ImageField is an instance of
+ the field's attr_class (TestImageFieldFile in this case) with no
+ name (name set to None).
+ """
+ p = self.PersonModel()
+ self.assertIsInstance(p.mugshot, TestImageFieldFile)
+ self.assertFalse(p.mugshot)
+
+ def test_assignment_to_None(self):
+ """
+ Assigning ImageField to None clears dimensions.
+ """
+ p = self.PersonModel(name="Joe", mugshot=self.file1)
+ self.check_dimensions(p, 4, 8)
+
+ # If image assigned to None, dimension fields should be cleared.
+ p.mugshot = None
+ self.check_dimensions(p, None, None)
+
+ p.mugshot = self.file2
+ self.check_dimensions(p, 8, 4)
+
+ def test_field_save_and_delete_methods(self):
+ """
+ Tests assignment using the field's save method and deletion using
+ the field's delete method.
+ """
+ p = self.PersonModel(name="Joe")
+ p.mugshot.save("mug", self.file1)
+ self.check_dimensions(p, 4, 8)
+
+ # A new file should update dimensions.
+ p.mugshot.save("mug", self.file2)
+ self.check_dimensions(p, 8, 4)
+
+ # Field and dimensions should be cleared after a delete.
+ p.mugshot.delete(save=False)
+ self.assertIsNone(p.mugshot.name)
+ self.check_dimensions(p, None, None)
+
+ def test_dimensions(self):
+ """
+ Dimensions are updated correctly in various situations.
+ """
+ p = self.PersonModel(name="Joe")
+
+ # Dimensions should get set if file is saved.
+ p.mugshot.save("mug", self.file1)
+ self.check_dimensions(p, 4, 8)
+
+ # Test dimensions after fetching from database.
+ p = self.PersonModel.objects.get(name="Joe")
+ # Bug 11084: Dimensions should not get recalculated if file is
+ # coming from the database. We test this by checking if the file
+ # was opened.
+ self.assertIs(p.mugshot.was_opened, False)
+ self.check_dimensions(p, 4, 8)
+ # After checking dimensions on the image field, the file will have
+ # opened.
+ self.assertIs(p.mugshot.was_opened, True)
+ # Dimensions should now be cached, and if we reset was_opened and
+ # check dimensions again, the file should not have opened.
+ p.mugshot.was_opened = False
+ self.check_dimensions(p, 4, 8)
+ self.assertIs(p.mugshot.was_opened, False)
+
+ # If we assign a new image to the instance, the dimensions should
+ # update.
+ p.mugshot = self.file2
+ self.check_dimensions(p, 8, 4)
+ # Dimensions were recalculated, and hence file should have opened.
+ self.assertIs(p.mugshot.was_opened, True)
+
+
+@skipIf(Image is None, "Pillow is required to test ImageField")
+class ImageFieldNoDimensionsTests(ImageFieldTwoDimensionsTests):
+ """
+ Tests behavior of an ImageField with no dimension fields.
+ """
+
+ PersonModel = Person
+
+ def test_post_init_not_connected(self):
+ person_model_id = id(self.PersonModel)
+ self.assertNotIn(
+ person_model_id,
+ [sender_id for (_, sender_id), *_ in signals.post_init.receivers],
+ )
+
+ def test_save_does_not_close_file(self):
+ p = self.PersonModel(name="Joe")
+ p.mugshot.save("mug", self.file1)
+ with p.mugshot as f:
+ # Underlying file object wasn’t closed.
+ self.assertEqual(f.tell(), 0)
+
+
+@skipIf(Image is None, "Pillow is required to test ImageField")
+class ImageFieldOneDimensionTests(ImageFieldTwoDimensionsTests):
+ """
+ Tests behavior of an ImageField with one dimensions field.
+ """
+
+ PersonModel = PersonWithHeight
+
+
+@skipIf(Image is None, "Pillow is required to test ImageField")
+class ImageFieldDimensionsFirstTests(ImageFieldTwoDimensionsTests):
+ """
+ Tests behavior of an ImageField where the dimensions fields are
+ defined before the ImageField.
+ """
+
+ PersonModel = PersonDimensionsFirst
+
+
+@skipIf(Image is None, "Pillow is required to test ImageField")
+class ImageFieldUsingFileTests(ImageFieldTwoDimensionsTests):
+ """
+ Tests behavior of an ImageField when assigning it a File instance
+ rather than an ImageFile instance.
+ """
+
+ PersonModel = PersonDimensionsFirst
+ File = File
+
+
+@skipIf(Image is None, "Pillow is required to test ImageField")
+class TwoImageFieldTests(ImageFieldTestMixin, TestCase):
+ """
+ Tests a model with two ImageFields.
+ """
+
+ PersonModel = PersonTwoImages
+
+ def test_constructor(self):
+ p = self.PersonModel(mugshot=self.file1, headshot=self.file2)
+ self.check_dimensions(p, 4, 8, "mugshot")
+ self.check_dimensions(p, 8, 4, "headshot")
+ p.save()
+ self.check_dimensions(p, 4, 8, "mugshot")
+ self.check_dimensions(p, 8, 4, "headshot")
+
+ def test_create(self):
+ p = self.PersonModel.objects.create(mugshot=self.file1, headshot=self.file2)
+ self.check_dimensions(p, 4, 8)
+ self.check_dimensions(p, 8, 4, "headshot")
+
+ def test_assignment(self):
+ p = self.PersonModel()
+ self.check_dimensions(p, None, None, "mugshot")
+ self.check_dimensions(p, None, None, "headshot")
+
+ p.mugshot = self.file1
+ self.check_dimensions(p, 4, 8, "mugshot")
+ self.check_dimensions(p, None, None, "headshot")
+ p.headshot = self.file2
+ self.check_dimensions(p, 4, 8, "mugshot")
+ self.check_dimensions(p, 8, 4, "headshot")
+
+ # Clear the ImageFields one at a time.
+ p.mugshot = None
+ self.check_dimensions(p, None, None, "mugshot")
+ self.check_dimensions(p, 8, 4, "headshot")
+ p.headshot = None
+ self.check_dimensions(p, None, None, "mugshot")
+ self.check_dimensions(p, None, None, "headshot")
+
+ def test_field_save_and_delete_methods(self):
+ p = self.PersonModel(name="Joe")
+ p.mugshot.save("mug", self.file1)
+ self.check_dimensions(p, 4, 8, "mugshot")
+ self.check_dimensions(p, None, None, "headshot")
+ p.headshot.save("head", self.file2)
+ self.check_dimensions(p, 4, 8, "mugshot")
+ self.check_dimensions(p, 8, 4, "headshot")
+
+ # We can use save=True when deleting the image field with null=True
+ # dimension fields and the other field has an image.
+ p.headshot.delete(save=True)
+ self.check_dimensions(p, 4, 8, "mugshot")
+ self.check_dimensions(p, None, None, "headshot")
+ p.mugshot.delete(save=False)
+ self.check_dimensions(p, None, None, "mugshot")
+ self.check_dimensions(p, None, None, "headshot")
+
+ def test_dimensions(self):
+ """
+ Dimensions are updated correctly in various situations.
+ """
+ p = self.PersonModel(name="Joe")
+
+ # Dimensions should get set for the saved file.
+ p.mugshot.save("mug", self.file1)
+ p.headshot.save("head", self.file2)
+ self.check_dimensions(p, 4, 8, "mugshot")
+ self.check_dimensions(p, 8, 4, "headshot")
+
+ # Test dimensions after fetching from database.
+ p = self.PersonModel.objects.get(name="Joe")
+ # Bug 11084: Dimensions should not get recalculated if file is
+ # coming from the database. We test this by checking if the file
+ # was opened.
+ self.assertIs(p.mugshot.was_opened, False)
+ self.assertIs(p.headshot.was_opened, False)
+ self.check_dimensions(p, 4, 8, "mugshot")
+ self.check_dimensions(p, 8, 4, "headshot")
+ # After checking dimensions on the image fields, the files will
+ # have been opened.
+ self.assertIs(p.mugshot.was_opened, True)
+ self.assertIs(p.headshot.was_opened, True)
+ # Dimensions should now be cached, and if we reset was_opened and
+ # check dimensions again, the file should not have opened.
+ p.mugshot.was_opened = False
+ p.headshot.was_opened = False
+ self.check_dimensions(p, 4, 8, "mugshot")
+ self.check_dimensions(p, 8, 4, "headshot")
+ self.assertIs(p.mugshot.was_opened, False)
+ self.assertIs(p.headshot.was_opened, False)
+
+ # If we assign a new image to the instance, the dimensions should
+ # update.
+ p.mugshot = self.file2
+ p.headshot = self.file1
+ self.check_dimensions(p, 8, 4, "mugshot")
+ self.check_dimensions(p, 4, 8, "headshot")
+ # Dimensions were recalculated, and hence file should have opened.
+ self.assertIs(p.mugshot.was_opened, True)
+ self.assertIs(p.headshot.was_opened, True)
diff --git a/testbed/django__django/tests/model_fields/test_integerfield.py b/testbed/django__django/tests/model_fields/test_integerfield.py
new file mode 100644
index 0000000000000000000000000000000000000000..6761589b7ebbd7fe0f5b51606b36856d365ffabf
--- /dev/null
+++ b/testbed/django__django/tests/model_fields/test_integerfield.py
@@ -0,0 +1,312 @@
+from unittest import SkipTest
+
+from django.core import validators
+from django.core.exceptions import ValidationError
+from django.db import IntegrityError, connection, models
+from django.test import SimpleTestCase, TestCase
+
+from .models import (
+ BigIntegerModel,
+ IntegerModel,
+ PositiveBigIntegerModel,
+ PositiveIntegerModel,
+ PositiveSmallIntegerModel,
+ SmallIntegerModel,
+)
+
+
+class IntegerFieldTests(TestCase):
+ model = IntegerModel
+ documented_range = (-2147483648, 2147483647)
+ rel_db_type_class = models.IntegerField
+
+ @property
+ def backend_range(self):
+ field = self.model._meta.get_field("value")
+ internal_type = field.get_internal_type()
+ return connection.ops.integer_field_range(internal_type)
+
+ def test_documented_range(self):
+ """
+ Values within the documented safe range pass validation, and can be
+ saved and retrieved without corruption.
+ """
+ min_value, max_value = self.documented_range
+
+ instance = self.model(value=min_value)
+ instance.full_clean()
+ instance.save()
+ qs = self.model.objects.filter(value__lte=min_value)
+ self.assertEqual(qs.count(), 1)
+ self.assertEqual(qs[0].value, min_value)
+
+ instance = self.model(value=max_value)
+ instance.full_clean()
+ instance.save()
+ qs = self.model.objects.filter(value__gte=max_value)
+ self.assertEqual(qs.count(), 1)
+ self.assertEqual(qs[0].value, max_value)
+
+ def test_backend_range_save(self):
+ """
+ Backend specific ranges can be saved without corruption.
+ """
+ min_value, max_value = self.backend_range
+
+ if min_value is not None:
+ instance = self.model(value=min_value)
+ instance.full_clean()
+ instance.save()
+ qs = self.model.objects.filter(value__lte=min_value)
+ self.assertEqual(qs.count(), 1)
+ self.assertEqual(qs[0].value, min_value)
+
+ if max_value is not None:
+ instance = self.model(value=max_value)
+ instance.full_clean()
+ instance.save()
+ qs = self.model.objects.filter(value__gte=max_value)
+ self.assertEqual(qs.count(), 1)
+ self.assertEqual(qs[0].value, max_value)
+
+ def test_backend_range_validation(self):
+ """
+ Backend specific ranges are enforced at the model validation level
+ (#12030).
+ """
+ min_value, max_value = self.backend_range
+
+ if min_value is not None:
+ instance = self.model(value=min_value - 1)
+ expected_message = validators.MinValueValidator.message % {
+ "limit_value": min_value,
+ }
+ with self.assertRaisesMessage(ValidationError, expected_message):
+ instance.full_clean()
+ instance.value = min_value
+ instance.full_clean()
+
+ if max_value is not None:
+ instance = self.model(value=max_value + 1)
+ expected_message = validators.MaxValueValidator.message % {
+ "limit_value": max_value,
+ }
+ with self.assertRaisesMessage(ValidationError, expected_message):
+ instance.full_clean()
+ instance.value = max_value
+ instance.full_clean()
+
+ def test_backend_range_min_value_lookups(self):
+ min_value = self.backend_range[0]
+ if min_value is None:
+ raise SkipTest("Backend doesn't define an integer min value.")
+ underflow_value = min_value - 1
+ self.model.objects.create(value=min_value)
+ # A refresh of obj is necessary because last_insert_id() is bugged
+ # on MySQL and returns invalid values.
+ obj = self.model.objects.get(value=min_value)
+ with self.assertNumQueries(0), self.assertRaises(self.model.DoesNotExist):
+ self.model.objects.get(value=underflow_value)
+ with self.assertNumQueries(1):
+ self.assertEqual(self.model.objects.get(value__gt=underflow_value), obj)
+ with self.assertNumQueries(1):
+ self.assertEqual(self.model.objects.get(value__gte=underflow_value), obj)
+ with self.assertNumQueries(0), self.assertRaises(self.model.DoesNotExist):
+ self.model.objects.get(value__lt=underflow_value)
+ with self.assertNumQueries(0), self.assertRaises(self.model.DoesNotExist):
+ self.model.objects.get(value__lte=underflow_value)
+
+ def test_backend_range_max_value_lookups(self):
+ max_value = self.backend_range[-1]
+ if max_value is None:
+ raise SkipTest("Backend doesn't define an integer max value.")
+ overflow_value = max_value + 1
+ obj = self.model.objects.create(value=max_value)
+ with self.assertNumQueries(0), self.assertRaises(self.model.DoesNotExist):
+ self.model.objects.get(value=overflow_value)
+ with self.assertNumQueries(0), self.assertRaises(self.model.DoesNotExist):
+ self.model.objects.get(value__gt=overflow_value)
+ with self.assertNumQueries(0), self.assertRaises(self.model.DoesNotExist):
+ self.model.objects.get(value__gte=overflow_value)
+ with self.assertNumQueries(1):
+ self.assertEqual(self.model.objects.get(value__lt=overflow_value), obj)
+ with self.assertNumQueries(1):
+ self.assertEqual(self.model.objects.get(value__lte=overflow_value), obj)
+
+ def test_redundant_backend_range_validators(self):
+ """
+ If there are stricter validators than the ones from the database
+ backend then the backend validators aren't added.
+ """
+ min_backend_value, max_backend_value = self.backend_range
+
+ for callable_limit in (True, False):
+ with self.subTest(callable_limit=callable_limit):
+ if min_backend_value is not None:
+ min_custom_value = min_backend_value + 1
+ limit_value = (
+ (lambda: min_custom_value)
+ if callable_limit
+ else min_custom_value
+ )
+ ranged_value_field = self.model._meta.get_field("value").__class__(
+ validators=[validators.MinValueValidator(limit_value)]
+ )
+ field_range_message = validators.MinValueValidator.message % {
+ "limit_value": min_custom_value,
+ }
+ with self.assertRaisesMessage(
+ ValidationError, "[%r]" % field_range_message
+ ):
+ ranged_value_field.run_validators(min_backend_value - 1)
+
+ if max_backend_value is not None:
+ max_custom_value = max_backend_value - 1
+ limit_value = (
+ (lambda: max_custom_value)
+ if callable_limit
+ else max_custom_value
+ )
+ ranged_value_field = self.model._meta.get_field("value").__class__(
+ validators=[validators.MaxValueValidator(limit_value)]
+ )
+ field_range_message = validators.MaxValueValidator.message % {
+ "limit_value": max_custom_value,
+ }
+ with self.assertRaisesMessage(
+ ValidationError, "[%r]" % field_range_message
+ ):
+ ranged_value_field.run_validators(max_backend_value + 1)
+
+ def test_types(self):
+ instance = self.model(value=1)
+ self.assertIsInstance(instance.value, int)
+ instance.save()
+ self.assertIsInstance(instance.value, int)
+ instance = self.model.objects.get()
+ self.assertIsInstance(instance.value, int)
+
+ def test_coercing(self):
+ self.model.objects.create(value="10")
+ instance = self.model.objects.get(value="10")
+ self.assertEqual(instance.value, 10)
+
+ def test_invalid_value(self):
+ tests = [
+ (TypeError, ()),
+ (TypeError, []),
+ (TypeError, {}),
+ (TypeError, set()),
+ (TypeError, object()),
+ (TypeError, complex()),
+ (ValueError, "non-numeric string"),
+ (ValueError, b"non-numeric byte-string"),
+ ]
+ for exception, value in tests:
+ with self.subTest(value):
+ msg = "Field 'value' expected a number but got %r." % (value,)
+ with self.assertRaisesMessage(exception, msg):
+ self.model.objects.create(value=value)
+
+ def test_rel_db_type(self):
+ field = self.model._meta.get_field("value")
+ rel_db_type = field.rel_db_type(connection)
+ self.assertEqual(rel_db_type, self.rel_db_type_class().db_type(connection))
+
+
+class SmallIntegerFieldTests(IntegerFieldTests):
+ model = SmallIntegerModel
+ documented_range = (-32768, 32767)
+ rel_db_type_class = models.SmallIntegerField
+
+
+class BigIntegerFieldTests(IntegerFieldTests):
+ model = BigIntegerModel
+ documented_range = (-9223372036854775808, 9223372036854775807)
+ rel_db_type_class = models.BigIntegerField
+
+
+class PositiveSmallIntegerFieldTests(IntegerFieldTests):
+ model = PositiveSmallIntegerModel
+ documented_range = (0, 32767)
+ rel_db_type_class = (
+ models.PositiveSmallIntegerField
+ if connection.features.related_fields_match_type
+ else models.SmallIntegerField
+ )
+
+
+class PositiveIntegerFieldTests(IntegerFieldTests):
+ model = PositiveIntegerModel
+ documented_range = (0, 2147483647)
+ rel_db_type_class = (
+ models.PositiveIntegerField
+ if connection.features.related_fields_match_type
+ else models.IntegerField
+ )
+
+ def test_negative_values(self):
+ p = PositiveIntegerModel.objects.create(value=0)
+ p.value = models.F("value") - 1
+ with self.assertRaises(IntegrityError):
+ p.save()
+
+
+class PositiveBigIntegerFieldTests(IntegerFieldTests):
+ model = PositiveBigIntegerModel
+ documented_range = (0, 9223372036854775807)
+ rel_db_type_class = (
+ models.PositiveBigIntegerField
+ if connection.features.related_fields_match_type
+ else models.BigIntegerField
+ )
+
+
+class ValidationTests(SimpleTestCase):
+ class Choices(models.IntegerChoices):
+ A = 1
+
+ def test_integerfield_cleans_valid_string(self):
+ f = models.IntegerField()
+ self.assertEqual(f.clean("2", None), 2)
+
+ def test_integerfield_raises_error_on_invalid_intput(self):
+ f = models.IntegerField()
+ with self.assertRaises(ValidationError):
+ f.clean("a", None)
+
+ def test_choices_validation_supports_named_groups(self):
+ f = models.IntegerField(choices=(("group", ((10, "A"), (20, "B"))), (30, "C")))
+ self.assertEqual(10, f.clean(10, None))
+
+ def test_nullable_integerfield_raises_error_with_blank_false(self):
+ f = models.IntegerField(null=True, blank=False)
+ with self.assertRaises(ValidationError):
+ f.clean(None, None)
+
+ def test_nullable_integerfield_cleans_none_on_null_and_blank_true(self):
+ f = models.IntegerField(null=True, blank=True)
+ self.assertIsNone(f.clean(None, None))
+
+ def test_integerfield_raises_error_on_empty_input(self):
+ f = models.IntegerField(null=False)
+ with self.assertRaises(ValidationError):
+ f.clean(None, None)
+ with self.assertRaises(ValidationError):
+ f.clean("", None)
+
+ def test_integerfield_validates_zero_against_choices(self):
+ f = models.IntegerField(choices=((1, 1),))
+ with self.assertRaises(ValidationError):
+ f.clean("0", None)
+
+ def test_enum_choices_cleans_valid_string(self):
+ f = models.IntegerField(choices=self.Choices)
+ self.assertEqual(f.clean("1", None), 1)
+
+ def test_enum_choices_invalid_input(self):
+ f = models.IntegerField(choices=self.Choices)
+ with self.assertRaises(ValidationError):
+ f.clean("A", None)
+ with self.assertRaises(ValidationError):
+ f.clean("3", None)
diff --git a/testbed/django__django/tests/model_fields/test_manytomanyfield.py b/testbed/django__django/tests/model_fields/test_manytomanyfield.py
new file mode 100644
index 0000000000000000000000000000000000000000..3dbc267634b634fee3fd4752bf41451a646fe65b
--- /dev/null
+++ b/testbed/django__django/tests/model_fields/test_manytomanyfield.py
@@ -0,0 +1,107 @@
+from django.apps import apps
+from django.db import models
+from django.test import SimpleTestCase, TestCase
+from django.test.utils import isolate_apps
+
+from .models import ManyToMany
+
+
+class ManyToManyFieldTests(SimpleTestCase):
+ def test_abstract_model_pending_operations(self):
+ """
+ Many-to-many fields declared on abstract models should not add lazy
+ relations to resolve relationship declared as string (#24215).
+ """
+ pending_ops_before = list(apps._pending_operations.items())
+
+ class AbstractManyToManyModel(models.Model):
+ fk = models.ForeignKey("missing.FK", models.CASCADE)
+
+ class Meta:
+ abstract = True
+
+ self.assertIs(AbstractManyToManyModel._meta.apps, apps)
+ self.assertEqual(
+ pending_ops_before,
+ list(apps._pending_operations.items()),
+ "Pending lookup added for a many-to-many field on an abstract model",
+ )
+
+ @isolate_apps("model_fields", "model_fields.tests")
+ def test_abstract_model_app_relative_foreign_key(self):
+ class AbstractReferent(models.Model):
+ reference = models.ManyToManyField("Referred", through="Through")
+
+ class Meta:
+ app_label = "model_fields"
+ abstract = True
+
+ def assert_app_model_resolved(label):
+ class Referred(models.Model):
+ class Meta:
+ app_label = label
+
+ class Through(models.Model):
+ referred = models.ForeignKey("Referred", on_delete=models.CASCADE)
+ referent = models.ForeignKey(
+ "ConcreteReferent", on_delete=models.CASCADE
+ )
+
+ class Meta:
+ app_label = label
+
+ class ConcreteReferent(AbstractReferent):
+ class Meta:
+ app_label = label
+
+ self.assertEqual(
+ ConcreteReferent._meta.get_field("reference").related_model, Referred
+ )
+ self.assertEqual(ConcreteReferent.reference.through, Through)
+
+ assert_app_model_resolved("model_fields")
+ assert_app_model_resolved("tests")
+
+ def test_invalid_to_parameter(self):
+ msg = (
+ "ManyToManyField(1) is invalid. First parameter to "
+ "ManyToManyField must be either a model, a model name, or the "
+ "string 'self'"
+ )
+ with self.assertRaisesMessage(TypeError, msg):
+
+ class MyModel(models.Model):
+ m2m = models.ManyToManyField(1)
+
+ @isolate_apps("model_fields")
+ def test_through_db_table_mutually_exclusive(self):
+ class Child(models.Model):
+ pass
+
+ class Through(models.Model):
+ referred = models.ForeignKey(Child, on_delete=models.CASCADE)
+ referent = models.ForeignKey(Child, on_delete=models.CASCADE)
+
+ msg = "Cannot specify a db_table if an intermediary model is used."
+ with self.assertRaisesMessage(ValueError, msg):
+
+ class MyModel(models.Model):
+ m2m = models.ManyToManyField(
+ Child,
+ through="Through",
+ db_table="custom_name",
+ )
+
+
+class ManyToManyFieldDBTests(TestCase):
+ def test_value_from_object_instance_without_pk(self):
+ obj = ManyToMany()
+ self.assertEqual(obj._meta.get_field("m2m").value_from_object(obj), [])
+
+ def test_value_from_object_instance_with_pk(self):
+ obj = ManyToMany.objects.create()
+ related_obj = ManyToMany.objects.create()
+ obj.m2m.add(related_obj)
+ self.assertEqual(
+ obj._meta.get_field("m2m").value_from_object(obj), [related_obj]
+ )
diff --git a/testbed/django__django/tests/model_fields/test_promises.py b/testbed/django__django/tests/model_fields/test_promises.py
new file mode 100644
index 0000000000000000000000000000000000000000..bfc09f590d65cada981bfe628704142af522ed05
--- /dev/null
+++ b/testbed/django__django/tests/model_fields/test_promises.py
@@ -0,0 +1,146 @@
+import datetime
+from decimal import Decimal
+
+from django.db.models import (
+ AutoField,
+ BinaryField,
+ BooleanField,
+ CharField,
+ DateField,
+ DateTimeField,
+ DecimalField,
+ EmailField,
+ FileField,
+ FilePathField,
+ FloatField,
+ GenericIPAddressField,
+ ImageField,
+ IntegerField,
+ IPAddressField,
+ PositiveBigIntegerField,
+ PositiveIntegerField,
+ PositiveSmallIntegerField,
+ SlugField,
+ SmallIntegerField,
+ TextField,
+ TimeField,
+ URLField,
+)
+from django.test import SimpleTestCase
+from django.utils.functional import lazy
+
+
+class PromiseTest(SimpleTestCase):
+ def test_AutoField(self):
+ lazy_func = lazy(lambda: 1, int)
+ self.assertIsInstance(
+ AutoField(primary_key=True).get_prep_value(lazy_func()), int
+ )
+
+ def test_BinaryField(self):
+ lazy_func = lazy(lambda: b"", bytes)
+ self.assertIsInstance(BinaryField().get_prep_value(lazy_func()), bytes)
+
+ def test_BooleanField(self):
+ lazy_func = lazy(lambda: True, bool)
+ self.assertIsInstance(BooleanField().get_prep_value(lazy_func()), bool)
+
+ def test_CharField(self):
+ lazy_func = lazy(lambda: "", str)
+ self.assertIsInstance(CharField().get_prep_value(lazy_func()), str)
+ lazy_func = lazy(lambda: 0, int)
+ self.assertIsInstance(CharField().get_prep_value(lazy_func()), str)
+
+ def test_DateField(self):
+ lazy_func = lazy(lambda: datetime.date.today(), datetime.date)
+ self.assertIsInstance(DateField().get_prep_value(lazy_func()), datetime.date)
+
+ def test_DateTimeField(self):
+ lazy_func = lazy(lambda: datetime.datetime.now(), datetime.datetime)
+ self.assertIsInstance(
+ DateTimeField().get_prep_value(lazy_func()), datetime.datetime
+ )
+
+ def test_DecimalField(self):
+ lazy_func = lazy(lambda: Decimal("1.2"), Decimal)
+ self.assertIsInstance(DecimalField().get_prep_value(lazy_func()), Decimal)
+
+ def test_EmailField(self):
+ lazy_func = lazy(lambda: "mailbox@domain.com", str)
+ self.assertIsInstance(EmailField().get_prep_value(lazy_func()), str)
+
+ def test_FileField(self):
+ lazy_func = lazy(lambda: "filename.ext", str)
+ self.assertIsInstance(FileField().get_prep_value(lazy_func()), str)
+ lazy_func = lazy(lambda: 0, int)
+ self.assertIsInstance(FileField().get_prep_value(lazy_func()), str)
+
+ def test_FilePathField(self):
+ lazy_func = lazy(lambda: "tests.py", str)
+ self.assertIsInstance(FilePathField().get_prep_value(lazy_func()), str)
+ lazy_func = lazy(lambda: 0, int)
+ self.assertIsInstance(FilePathField().get_prep_value(lazy_func()), str)
+
+ def test_FloatField(self):
+ lazy_func = lazy(lambda: 1.2, float)
+ self.assertIsInstance(FloatField().get_prep_value(lazy_func()), float)
+
+ def test_ImageField(self):
+ lazy_func = lazy(lambda: "filename.ext", str)
+ self.assertIsInstance(ImageField().get_prep_value(lazy_func()), str)
+
+ def test_IntegerField(self):
+ lazy_func = lazy(lambda: 1, int)
+ self.assertIsInstance(IntegerField().get_prep_value(lazy_func()), int)
+
+ def test_IPAddressField(self):
+ lazy_func = lazy(lambda: "127.0.0.1", str)
+ self.assertIsInstance(IPAddressField().get_prep_value(lazy_func()), str)
+ lazy_func = lazy(lambda: 0, int)
+ self.assertIsInstance(IPAddressField().get_prep_value(lazy_func()), str)
+
+ def test_GenericIPAddressField(self):
+ lazy_func = lazy(lambda: "127.0.0.1", str)
+ self.assertIsInstance(GenericIPAddressField().get_prep_value(lazy_func()), str)
+ lazy_func = lazy(lambda: 0, int)
+ self.assertIsInstance(GenericIPAddressField().get_prep_value(lazy_func()), str)
+
+ def test_PositiveIntegerField(self):
+ lazy_func = lazy(lambda: 1, int)
+ self.assertIsInstance(PositiveIntegerField().get_prep_value(lazy_func()), int)
+
+ def test_PositiveSmallIntegerField(self):
+ lazy_func = lazy(lambda: 1, int)
+ self.assertIsInstance(
+ PositiveSmallIntegerField().get_prep_value(lazy_func()), int
+ )
+
+ def test_PositiveBigIntegerField(self):
+ lazy_func = lazy(lambda: 1, int)
+ self.assertIsInstance(
+ PositiveBigIntegerField().get_prep_value(lazy_func()), int
+ )
+
+ def test_SlugField(self):
+ lazy_func = lazy(lambda: "slug", str)
+ self.assertIsInstance(SlugField().get_prep_value(lazy_func()), str)
+ lazy_func = lazy(lambda: 0, int)
+ self.assertIsInstance(SlugField().get_prep_value(lazy_func()), str)
+
+ def test_SmallIntegerField(self):
+ lazy_func = lazy(lambda: 1, int)
+ self.assertIsInstance(SmallIntegerField().get_prep_value(lazy_func()), int)
+
+ def test_TextField(self):
+ lazy_func = lazy(lambda: "Abc", str)
+ self.assertIsInstance(TextField().get_prep_value(lazy_func()), str)
+ lazy_func = lazy(lambda: 0, int)
+ self.assertIsInstance(TextField().get_prep_value(lazy_func()), str)
+
+ def test_TimeField(self):
+ lazy_func = lazy(lambda: datetime.datetime.now().time(), datetime.time)
+ self.assertIsInstance(TimeField().get_prep_value(lazy_func()), datetime.time)
+
+ def test_URLField(self):
+ lazy_func = lazy(lambda: "http://domain.com", str)
+ self.assertIsInstance(URLField().get_prep_value(lazy_func()), str)
diff --git a/testbed/django__django/tests/model_fields/test_slugfield.py b/testbed/django__django/tests/model_fields/test_slugfield.py
new file mode 100644
index 0000000000000000000000000000000000000000..4d000c927686691a797271b620240cd6e1899166
--- /dev/null
+++ b/testbed/django__django/tests/model_fields/test_slugfield.py
@@ -0,0 +1,21 @@
+from django.test import TestCase
+
+from .models import BigS, UnicodeSlugField
+
+
+class SlugFieldTests(TestCase):
+ def test_slugfield_max_length(self):
+ """
+ SlugField honors max_length.
+ """
+ bs = BigS.objects.create(s="slug" * 50)
+ bs = BigS.objects.get(pk=bs.pk)
+ self.assertEqual(bs.s, "slug" * 50)
+
+ def test_slugfield_unicode_max_length(self):
+ """
+ SlugField with allow_unicode=True honors max_length.
+ """
+ bs = UnicodeSlugField.objects.create(s="你好你好" * 50)
+ bs = UnicodeSlugField.objects.get(pk=bs.pk)
+ self.assertEqual(bs.s, "你好你好" * 50)
diff --git a/testbed/django__django/tests/model_fields/test_textfield.py b/testbed/django__django/tests/model_fields/test_textfield.py
new file mode 100644
index 0000000000000000000000000000000000000000..63d6f1cda2a35063c748f9971f1c37948d85a142
--- /dev/null
+++ b/testbed/django__django/tests/model_fields/test_textfield.py
@@ -0,0 +1,45 @@
+from django import forms
+from django.db import models
+from django.test import SimpleTestCase, TestCase
+
+from .models import Post
+
+
+class TextFieldTests(TestCase):
+ def test_max_length_passed_to_formfield(self):
+ """
+ TextField passes its max_length attribute to form fields created using
+ their formfield() method.
+ """
+ tf1 = models.TextField()
+ tf2 = models.TextField(max_length=2345)
+ self.assertIsNone(tf1.formfield().max_length)
+ self.assertEqual(2345, tf2.formfield().max_length)
+
+ def test_choices_generates_select_widget(self):
+ """A TextField with choices uses a Select widget."""
+ f = models.TextField(choices=[("A", "A"), ("B", "B")])
+ self.assertIsInstance(f.formfield().widget, forms.Select)
+
+ def test_to_python(self):
+ """TextField.to_python() should return a string."""
+ f = models.TextField()
+ self.assertEqual(f.to_python(1), "1")
+
+ def test_lookup_integer_in_textfield(self):
+ self.assertEqual(Post.objects.filter(body=24).count(), 0)
+
+ def test_emoji(self):
+ p = Post.objects.create(title="Whatever", body="Smile 😀.")
+ p.refresh_from_db()
+ self.assertEqual(p.body, "Smile 😀.")
+
+
+class TestMethods(SimpleTestCase):
+ def test_deconstruct(self):
+ field = models.TextField()
+ *_, kwargs = field.deconstruct()
+ self.assertEqual(kwargs, {})
+ field = models.TextField(db_collation="utf8_esperanto_ci")
+ *_, kwargs = field.deconstruct()
+ self.assertEqual(kwargs, {"db_collation": "utf8_esperanto_ci"})
diff --git a/testbed/django__django/tests/model_fields/test_uuid.py b/testbed/django__django/tests/model_fields/test_uuid.py
new file mode 100644
index 0000000000000000000000000000000000000000..c7776cf6b57ee5fc38fdf07fb59b921a8dbe0df8
--- /dev/null
+++ b/testbed/django__django/tests/model_fields/test_uuid.py
@@ -0,0 +1,343 @@
+import json
+import uuid
+
+from django.core import exceptions, serializers
+from django.db import IntegrityError, connection, models
+from django.db.models import CharField, F, Value
+from django.db.models.functions import Concat, Repeat
+from django.test import (
+ SimpleTestCase,
+ TestCase,
+ TransactionTestCase,
+ skipUnlessDBFeature,
+)
+
+from .models import (
+ NullableUUIDModel,
+ PrimaryKeyUUIDModel,
+ RelatedToUUIDModel,
+ UUIDGrandchild,
+ UUIDModel,
+)
+
+
+class TestSaveLoad(TestCase):
+ def test_uuid_instance(self):
+ instance = UUIDModel.objects.create(field=uuid.uuid4())
+ loaded = UUIDModel.objects.get()
+ self.assertEqual(loaded.field, instance.field)
+
+ def test_str_instance_no_hyphens(self):
+ UUIDModel.objects.create(field="550e8400e29b41d4a716446655440000")
+ loaded = UUIDModel.objects.get()
+ self.assertEqual(loaded.field, uuid.UUID("550e8400e29b41d4a716446655440000"))
+
+ def test_str_instance_hyphens(self):
+ UUIDModel.objects.create(field="550e8400-e29b-41d4-a716-446655440000")
+ loaded = UUIDModel.objects.get()
+ self.assertEqual(loaded.field, uuid.UUID("550e8400e29b41d4a716446655440000"))
+
+ def test_str_instance_bad_hyphens(self):
+ UUIDModel.objects.create(field="550e84-00-e29b-41d4-a716-4-466-55440000")
+ loaded = UUIDModel.objects.get()
+ self.assertEqual(loaded.field, uuid.UUID("550e8400e29b41d4a716446655440000"))
+
+ def test_null_handling(self):
+ NullableUUIDModel.objects.create(field=None)
+ loaded = NullableUUIDModel.objects.get()
+ self.assertIsNone(loaded.field)
+
+ def test_pk_validated(self):
+ with self.assertRaisesMessage(
+ exceptions.ValidationError, "is not a valid UUID"
+ ):
+ PrimaryKeyUUIDModel.objects.get(pk={})
+
+ with self.assertRaisesMessage(
+ exceptions.ValidationError, "is not a valid UUID"
+ ):
+ PrimaryKeyUUIDModel.objects.get(pk=[])
+
+ def test_wrong_value(self):
+ with self.assertRaisesMessage(
+ exceptions.ValidationError, "is not a valid UUID"
+ ):
+ UUIDModel.objects.get(field="not-a-uuid")
+
+ with self.assertRaisesMessage(
+ exceptions.ValidationError, "is not a valid UUID"
+ ):
+ UUIDModel.objects.create(field="not-a-uuid")
+
+
+class TestMethods(SimpleTestCase):
+ def test_deconstruct(self):
+ field = models.UUIDField()
+ name, path, args, kwargs = field.deconstruct()
+ self.assertEqual(kwargs, {})
+
+ def test_to_python(self):
+ self.assertIsNone(models.UUIDField().to_python(None))
+
+ def test_to_python_int_values(self):
+ self.assertEqual(
+ models.UUIDField().to_python(0),
+ uuid.UUID("00000000-0000-0000-0000-000000000000"),
+ )
+ # Works for integers less than 128 bits.
+ self.assertEqual(
+ models.UUIDField().to_python((2**128) - 1),
+ uuid.UUID("ffffffff-ffff-ffff-ffff-ffffffffffff"),
+ )
+
+ def test_to_python_int_too_large(self):
+ # Fails for integers larger than 128 bits.
+ with self.assertRaises(exceptions.ValidationError):
+ models.UUIDField().to_python(2**128)
+
+
+class TestQuerying(TestCase):
+ @classmethod
+ def setUpTestData(cls):
+ cls.objs = [
+ NullableUUIDModel.objects.create(
+ field=uuid.UUID("25d405be-4895-4d50-9b2e-d6695359ce47"),
+ ),
+ NullableUUIDModel.objects.create(field="550e8400e29b41d4a716446655440000"),
+ NullableUUIDModel.objects.create(field=None),
+ ]
+
+ def assertSequenceEqualWithoutHyphens(self, qs, result):
+ """
+ Backends with a native datatype for UUID don't support fragment lookups
+ without hyphens because they store values with them.
+ """
+ self.assertSequenceEqual(
+ qs,
+ [] if connection.features.has_native_uuid_field else result,
+ )
+
+ def test_exact(self):
+ self.assertSequenceEqual(
+ NullableUUIDModel.objects.filter(
+ field__exact="550e8400e29b41d4a716446655440000"
+ ),
+ [self.objs[1]],
+ )
+ self.assertSequenceEqual(
+ NullableUUIDModel.objects.filter(
+ field__exact="550e8400-e29b-41d4-a716-446655440000"
+ ),
+ [self.objs[1]],
+ )
+
+ def test_iexact(self):
+ self.assertSequenceEqualWithoutHyphens(
+ NullableUUIDModel.objects.filter(
+ field__iexact="550E8400E29B41D4A716446655440000"
+ ),
+ [self.objs[1]],
+ )
+ self.assertSequenceEqual(
+ NullableUUIDModel.objects.filter(
+ field__iexact="550E8400-E29B-41D4-A716-446655440000"
+ ),
+ [self.objs[1]],
+ )
+
+ def test_isnull(self):
+ self.assertSequenceEqual(
+ NullableUUIDModel.objects.filter(field__isnull=True), [self.objs[2]]
+ )
+
+ def test_contains(self):
+ self.assertSequenceEqualWithoutHyphens(
+ NullableUUIDModel.objects.filter(field__contains="8400e29b"),
+ [self.objs[1]],
+ )
+ self.assertSequenceEqual(
+ NullableUUIDModel.objects.filter(field__contains="8400-e29b"),
+ [self.objs[1]],
+ )
+
+ def test_icontains(self):
+ self.assertSequenceEqualWithoutHyphens(
+ NullableUUIDModel.objects.filter(field__icontains="8400E29B"),
+ [self.objs[1]],
+ )
+ self.assertSequenceEqual(
+ NullableUUIDModel.objects.filter(field__icontains="8400-E29B"),
+ [self.objs[1]],
+ )
+
+ def test_startswith(self):
+ self.assertSequenceEqualWithoutHyphens(
+ NullableUUIDModel.objects.filter(field__startswith="550e8400e29b4"),
+ [self.objs[1]],
+ )
+ self.assertSequenceEqual(
+ NullableUUIDModel.objects.filter(field__startswith="550e8400-e29b-4"),
+ [self.objs[1]],
+ )
+
+ def test_istartswith(self):
+ self.assertSequenceEqualWithoutHyphens(
+ NullableUUIDModel.objects.filter(field__istartswith="550E8400E29B4"),
+ [self.objs[1]],
+ )
+ self.assertSequenceEqual(
+ NullableUUIDModel.objects.filter(field__istartswith="550E8400-E29B-4"),
+ [self.objs[1]],
+ )
+
+ def test_endswith(self):
+ self.assertSequenceEqualWithoutHyphens(
+ NullableUUIDModel.objects.filter(field__endswith="a716446655440000"),
+ [self.objs[1]],
+ )
+ self.assertSequenceEqual(
+ NullableUUIDModel.objects.filter(field__endswith="a716-446655440000"),
+ [self.objs[1]],
+ )
+
+ def test_iendswith(self):
+ self.assertSequenceEqualWithoutHyphens(
+ NullableUUIDModel.objects.filter(field__iendswith="A716446655440000"),
+ [self.objs[1]],
+ )
+ self.assertSequenceEqual(
+ NullableUUIDModel.objects.filter(field__iendswith="A716-446655440000"),
+ [self.objs[1]],
+ )
+
+ def test_filter_with_expr(self):
+ self.assertSequenceEqualWithoutHyphens(
+ NullableUUIDModel.objects.annotate(
+ value=Concat(Value("8400"), Value("e29b"), output_field=CharField()),
+ ).filter(field__contains=F("value")),
+ [self.objs[1]],
+ )
+ self.assertSequenceEqual(
+ NullableUUIDModel.objects.annotate(
+ value=Concat(
+ Value("8400"), Value("-"), Value("e29b"), output_field=CharField()
+ ),
+ ).filter(field__contains=F("value")),
+ [self.objs[1]],
+ )
+ self.assertSequenceEqual(
+ NullableUUIDModel.objects.annotate(
+ value=Repeat(Value("0"), 4, output_field=CharField()),
+ ).filter(field__contains=F("value")),
+ [self.objs[1]],
+ )
+
+
+class TestSerialization(SimpleTestCase):
+ test_data = (
+ '[{"fields": {"field": "550e8400-e29b-41d4-a716-446655440000"}, '
+ '"model": "model_fields.uuidmodel", "pk": null}]'
+ )
+ nullable_test_data = (
+ '[{"fields": {"field": null}, '
+ '"model": "model_fields.nullableuuidmodel", "pk": null}]'
+ )
+
+ def test_dumping(self):
+ instance = UUIDModel(field=uuid.UUID("550e8400e29b41d4a716446655440000"))
+ data = serializers.serialize("json", [instance])
+ self.assertEqual(json.loads(data), json.loads(self.test_data))
+
+ def test_loading(self):
+ instance = list(serializers.deserialize("json", self.test_data))[0].object
+ self.assertEqual(
+ instance.field, uuid.UUID("550e8400-e29b-41d4-a716-446655440000")
+ )
+
+ def test_nullable_loading(self):
+ instance = list(serializers.deserialize("json", self.nullable_test_data))[
+ 0
+ ].object
+ self.assertIsNone(instance.field)
+
+
+class TestValidation(SimpleTestCase):
+ def test_invalid_uuid(self):
+ field = models.UUIDField()
+ with self.assertRaises(exceptions.ValidationError) as cm:
+ field.clean("550e8400", None)
+ self.assertEqual(cm.exception.code, "invalid")
+ self.assertEqual(
+ cm.exception.message % cm.exception.params,
+ "“550e8400” is not a valid UUID.",
+ )
+
+ def test_uuid_instance_ok(self):
+ field = models.UUIDField()
+ field.clean(uuid.uuid4(), None) # no error
+
+
+class TestAsPrimaryKey(TestCase):
+ def test_creation(self):
+ PrimaryKeyUUIDModel.objects.create()
+ loaded = PrimaryKeyUUIDModel.objects.get()
+ self.assertIsInstance(loaded.pk, uuid.UUID)
+
+ def test_uuid_pk_on_save(self):
+ saved = PrimaryKeyUUIDModel.objects.create(id=None)
+ loaded = PrimaryKeyUUIDModel.objects.get()
+ self.assertIsNotNone(loaded.id, None)
+ self.assertEqual(loaded.id, saved.id)
+
+ def test_uuid_pk_on_bulk_create(self):
+ u1 = PrimaryKeyUUIDModel()
+ u2 = PrimaryKeyUUIDModel(id=None)
+ PrimaryKeyUUIDModel.objects.bulk_create([u1, u2])
+ # The two objects were correctly created.
+ u1_found = PrimaryKeyUUIDModel.objects.filter(id=u1.id).exists()
+ u2_found = PrimaryKeyUUIDModel.objects.exclude(id=u1.id).exists()
+ self.assertTrue(u1_found)
+ self.assertTrue(u2_found)
+ self.assertEqual(PrimaryKeyUUIDModel.objects.count(), 2)
+
+ def test_underlying_field(self):
+ pk_model = PrimaryKeyUUIDModel.objects.create()
+ RelatedToUUIDModel.objects.create(uuid_fk=pk_model)
+ related = RelatedToUUIDModel.objects.get()
+ self.assertEqual(related.uuid_fk.pk, related.uuid_fk_id)
+
+ def test_update_with_related_model_instance(self):
+ # regression for #24611
+ u1 = PrimaryKeyUUIDModel.objects.create()
+ u2 = PrimaryKeyUUIDModel.objects.create()
+ r = RelatedToUUIDModel.objects.create(uuid_fk=u1)
+ RelatedToUUIDModel.objects.update(uuid_fk=u2)
+ r.refresh_from_db()
+ self.assertEqual(r.uuid_fk, u2)
+
+ def test_update_with_related_model_id(self):
+ u1 = PrimaryKeyUUIDModel.objects.create()
+ u2 = PrimaryKeyUUIDModel.objects.create()
+ r = RelatedToUUIDModel.objects.create(uuid_fk=u1)
+ RelatedToUUIDModel.objects.update(uuid_fk=u2.pk)
+ r.refresh_from_db()
+ self.assertEqual(r.uuid_fk, u2)
+
+ def test_two_level_foreign_keys(self):
+ gc = UUIDGrandchild()
+ # exercises ForeignKey.get_db_prep_value()
+ gc.save()
+ self.assertIsInstance(gc.uuidchild_ptr_id, uuid.UUID)
+ gc.refresh_from_db()
+ self.assertIsInstance(gc.uuidchild_ptr_id, uuid.UUID)
+
+
+class TestAsPrimaryKeyTransactionTests(TransactionTestCase):
+ # Need a TransactionTestCase to avoid deferring FK constraint checking.
+ available_apps = ["model_fields"]
+
+ @skipUnlessDBFeature("supports_foreign_keys")
+ def test_unsaved_fk(self):
+ u1 = PrimaryKeyUUIDModel()
+ with self.assertRaises(IntegrityError):
+ RelatedToUUIDModel.objects.create(uuid_fk=u1)
diff --git a/testbed/django__django/tests/model_forms/test_modelchoicefield.py b/testbed/django__django/tests/model_forms/test_modelchoicefield.py
new file mode 100644
index 0000000000000000000000000000000000000000..19e9db69a0588b4abff274ff2e35a31d4fd73686
--- /dev/null
+++ b/testbed/django__django/tests/model_forms/test_modelchoicefield.py
@@ -0,0 +1,449 @@
+import datetime
+
+from django import forms
+from django.core.exceptions import ValidationError
+from django.forms.models import ModelChoiceIterator, ModelChoiceIteratorValue
+from django.forms.widgets import CheckboxSelectMultiple
+from django.template import Context, Template
+from django.test import TestCase
+
+from .models import Article, Author, Book, Category, Writer
+
+
+class ModelChoiceFieldTests(TestCase):
+ @classmethod
+ def setUpTestData(cls):
+ cls.c1 = Category.objects.create(
+ name="Entertainment", slug="entertainment", url="entertainment"
+ )
+ cls.c2 = Category.objects.create(name="A test", slug="test", url="test")
+ cls.c3 = Category.objects.create(name="Third", slug="third-test", url="third")
+
+ def test_basics(self):
+ f = forms.ModelChoiceField(Category.objects.all())
+ self.assertEqual(
+ list(f.choices),
+ [
+ ("", "---------"),
+ (self.c1.pk, "Entertainment"),
+ (self.c2.pk, "A test"),
+ (self.c3.pk, "Third"),
+ ],
+ )
+ with self.assertRaises(ValidationError):
+ f.clean("")
+ with self.assertRaises(ValidationError):
+ f.clean(None)
+ with self.assertRaises(ValidationError):
+ f.clean(0)
+
+ # Invalid types that require TypeError to be caught.
+ with self.assertRaises(ValidationError):
+ f.clean([["fail"]])
+ with self.assertRaises(ValidationError):
+ f.clean([{"foo": "bar"}])
+
+ self.assertEqual(f.clean(self.c2.id).name, "A test")
+ self.assertEqual(f.clean(self.c3.id).name, "Third")
+
+ # Add a Category object *after* the ModelChoiceField has already been
+ # instantiated. This proves clean() checks the database during clean()
+ # rather than caching it at instantiation time.
+ c4 = Category.objects.create(name="Fourth", url="4th")
+ self.assertEqual(f.clean(c4.id).name, "Fourth")
+
+ # Delete a Category object *after* the ModelChoiceField has already been
+ # instantiated. This proves clean() checks the database during clean()
+ # rather than caching it at instantiation time.
+ Category.objects.get(url="4th").delete()
+ msg = (
+ "['Select a valid choice. That choice is not one of the available "
+ "choices.']"
+ )
+ with self.assertRaisesMessage(ValidationError, msg):
+ f.clean(c4.id)
+
+ def test_clean_model_instance(self):
+ f = forms.ModelChoiceField(Category.objects.all())
+ self.assertEqual(f.clean(self.c1), self.c1)
+ # An instance of incorrect model.
+ msg = (
+ "['Select a valid choice. That choice is not one of the available "
+ "choices.']"
+ )
+ with self.assertRaisesMessage(ValidationError, msg):
+ f.clean(Book.objects.create())
+
+ def test_clean_to_field_name(self):
+ f = forms.ModelChoiceField(Category.objects.all(), to_field_name="slug")
+ self.assertEqual(f.clean(self.c1.slug), self.c1)
+ self.assertEqual(f.clean(self.c1), self.c1)
+
+ def test_choices(self):
+ f = forms.ModelChoiceField(
+ Category.objects.filter(pk=self.c1.id), required=False
+ )
+ self.assertIsNone(f.clean(""))
+ self.assertEqual(f.clean(str(self.c1.id)).name, "Entertainment")
+ with self.assertRaises(ValidationError):
+ f.clean("100")
+
+ # len() can be called on choices.
+ self.assertEqual(len(f.choices), 2)
+
+ # queryset can be changed after the field is created.
+ f.queryset = Category.objects.exclude(name="Third").order_by("pk")
+ self.assertEqual(
+ list(f.choices),
+ [
+ ("", "---------"),
+ (self.c1.pk, "Entertainment"),
+ (self.c2.pk, "A test"),
+ ],
+ )
+ self.assertEqual(f.clean(self.c2.id).name, "A test")
+ with self.assertRaises(ValidationError):
+ f.clean(self.c3.id)
+
+ # Choices can be iterated repeatedly.
+ gen_one = list(f.choices)
+ gen_two = f.choices
+ self.assertEqual(gen_one[2], (self.c2.pk, "A test"))
+ self.assertEqual(
+ list(gen_two),
+ [
+ ("", "---------"),
+ (self.c1.pk, "Entertainment"),
+ (self.c2.pk, "A test"),
+ ],
+ )
+
+ # Overriding label_from_instance() to print custom labels.
+ f.queryset = Category.objects.order_by("pk")
+ f.label_from_instance = lambda obj: "category " + str(obj)
+ self.assertEqual(
+ list(f.choices),
+ [
+ ("", "---------"),
+ (self.c1.pk, "category Entertainment"),
+ (self.c2.pk, "category A test"),
+ (self.c3.pk, "category Third"),
+ ],
+ )
+
+ def test_choices_freshness(self):
+ f = forms.ModelChoiceField(Category.objects.order_by("pk"))
+ self.assertEqual(len(f.choices), 4)
+ self.assertEqual(
+ list(f.choices),
+ [
+ ("", "---------"),
+ (self.c1.pk, "Entertainment"),
+ (self.c2.pk, "A test"),
+ (self.c3.pk, "Third"),
+ ],
+ )
+ c4 = Category.objects.create(name="Fourth", slug="4th", url="4th")
+ self.assertEqual(len(f.choices), 5)
+ self.assertEqual(
+ list(f.choices),
+ [
+ ("", "---------"),
+ (self.c1.pk, "Entertainment"),
+ (self.c2.pk, "A test"),
+ (self.c3.pk, "Third"),
+ (c4.pk, "Fourth"),
+ ],
+ )
+
+ def test_choices_bool(self):
+ f = forms.ModelChoiceField(Category.objects.all(), empty_label=None)
+ self.assertIs(bool(f.choices), True)
+ Category.objects.all().delete()
+ self.assertIs(bool(f.choices), False)
+
+ def test_choices_bool_empty_label(self):
+ f = forms.ModelChoiceField(Category.objects.all(), empty_label="--------")
+ Category.objects.all().delete()
+ self.assertIs(bool(f.choices), True)
+
+ def test_choices_radio_blank(self):
+ choices = [
+ (self.c1.pk, "Entertainment"),
+ (self.c2.pk, "A test"),
+ (self.c3.pk, "Third"),
+ ]
+ categories = Category.objects.order_by("pk")
+ for widget in [forms.RadioSelect, forms.RadioSelect()]:
+ for blank in [True, False]:
+ with self.subTest(widget=widget, blank=blank):
+ f = forms.ModelChoiceField(
+ categories,
+ widget=widget,
+ blank=blank,
+ )
+ self.assertEqual(
+ list(f.choices),
+ [("", "---------")] + choices if blank else choices,
+ )
+
+ def test_deepcopies_widget(self):
+ class ModelChoiceForm(forms.Form):
+ category = forms.ModelChoiceField(Category.objects.all())
+
+ form1 = ModelChoiceForm()
+ field1 = form1.fields["category"]
+ # To allow the widget to change the queryset of field1.widget.choices
+ # without affecting other forms, the following must hold (#11183):
+ self.assertIsNot(field1, ModelChoiceForm.base_fields["category"])
+ self.assertIs(field1.widget.choices.field, field1)
+
+ def test_result_cache_not_shared(self):
+ class ModelChoiceForm(forms.Form):
+ category = forms.ModelChoiceField(Category.objects.all())
+
+ form1 = ModelChoiceForm()
+ self.assertCountEqual(
+ form1.fields["category"].queryset, [self.c1, self.c2, self.c3]
+ )
+ form2 = ModelChoiceForm()
+ self.assertIsNone(form2.fields["category"].queryset._result_cache)
+
+ def test_queryset_none(self):
+ class ModelChoiceForm(forms.Form):
+ category = forms.ModelChoiceField(queryset=None)
+
+ def __init__(self, *args, **kwargs):
+ super().__init__(*args, **kwargs)
+ self.fields["category"].queryset = Category.objects.filter(
+ slug__contains="test"
+ )
+
+ form = ModelChoiceForm()
+ self.assertCountEqual(form.fields["category"].queryset, [self.c2, self.c3])
+
+ def test_no_extra_query_when_accessing_attrs(self):
+ """
+ ModelChoiceField with RadioSelect widget doesn't produce unnecessary
+ db queries when accessing its BoundField's attrs.
+ """
+
+ class ModelChoiceForm(forms.Form):
+ category = forms.ModelChoiceField(
+ Category.objects.all(), widget=forms.RadioSelect
+ )
+
+ form = ModelChoiceForm()
+ field = form["category"] # BoundField
+ template = Template("{{ field.name }}{{ field }}{{ field.help_text }}")
+ with self.assertNumQueries(1):
+ template.render(Context({"field": field}))
+
+ def test_disabled_modelchoicefield(self):
+ class ModelChoiceForm(forms.ModelForm):
+ author = forms.ModelChoiceField(Author.objects.all(), disabled=True)
+
+ class Meta:
+ model = Book
+ fields = ["author"]
+
+ book = Book.objects.create(author=Writer.objects.create(name="Test writer"))
+ form = ModelChoiceForm({}, instance=book)
+ self.assertEqual(
+ form.errors["author"],
+ ["Select a valid choice. That choice is not one of the available choices."],
+ )
+
+ def test_disabled_modelchoicefield_has_changed(self):
+ field = forms.ModelChoiceField(Author.objects.all(), disabled=True)
+ self.assertIs(field.has_changed("x", "y"), False)
+
+ def test_disabled_modelchoicefield_initial_model_instance(self):
+ class ModelChoiceForm(forms.Form):
+ categories = forms.ModelChoiceField(
+ Category.objects.all(),
+ disabled=True,
+ initial=self.c1,
+ )
+
+ self.assertTrue(ModelChoiceForm(data={"categories": self.c1.pk}).is_valid())
+
+ def test_disabled_multiplemodelchoicefield(self):
+ class ArticleForm(forms.ModelForm):
+ categories = forms.ModelMultipleChoiceField(
+ Category.objects.all(), required=False
+ )
+
+ class Meta:
+ model = Article
+ fields = ["categories"]
+
+ category1 = Category.objects.create(name="cat1")
+ category2 = Category.objects.create(name="cat2")
+ article = Article.objects.create(
+ pub_date=datetime.date(1988, 1, 4),
+ writer=Writer.objects.create(name="Test writer"),
+ )
+ article.categories.set([category1.pk])
+
+ form = ArticleForm(data={"categories": [category2.pk]}, instance=article)
+ self.assertEqual(form.errors, {})
+ self.assertEqual(
+ [x.pk for x in form.cleaned_data["categories"]], [category2.pk]
+ )
+ # Disabled fields use the value from `instance` rather than `data`.
+ form = ArticleForm(data={"categories": [category2.pk]}, instance=article)
+ form.fields["categories"].disabled = True
+ self.assertEqual(form.errors, {})
+ self.assertEqual(
+ [x.pk for x in form.cleaned_data["categories"]], [category1.pk]
+ )
+
+ def test_disabled_modelmultiplechoicefield_has_changed(self):
+ field = forms.ModelMultipleChoiceField(Author.objects.all(), disabled=True)
+ self.assertIs(field.has_changed("x", "y"), False)
+
+ def test_overridable_choice_iterator(self):
+ """
+ Iterator defaults to ModelChoiceIterator and can be overridden with
+ the iterator attribute on a ModelChoiceField subclass.
+ """
+ field = forms.ModelChoiceField(Category.objects.all())
+ self.assertIsInstance(field.choices, ModelChoiceIterator)
+
+ class CustomModelChoiceIterator(ModelChoiceIterator):
+ pass
+
+ class CustomModelChoiceField(forms.ModelChoiceField):
+ iterator = CustomModelChoiceIterator
+
+ field = CustomModelChoiceField(Category.objects.all())
+ self.assertIsInstance(field.choices, CustomModelChoiceIterator)
+
+ def test_choice_iterator_passes_model_to_widget(self):
+ class CustomCheckboxSelectMultiple(CheckboxSelectMultiple):
+ def create_option(
+ self, name, value, label, selected, index, subindex=None, attrs=None
+ ):
+ option = super().create_option(
+ name, value, label, selected, index, subindex, attrs
+ )
+ # Modify the HTML based on the object being rendered.
+ c = value.instance
+ option["attrs"]["data-slug"] = c.slug
+ return option
+
+ class CustomModelMultipleChoiceField(forms.ModelMultipleChoiceField):
+ widget = CustomCheckboxSelectMultiple
+
+ field = CustomModelMultipleChoiceField(Category.objects.order_by("pk"))
+ self.assertHTMLEqual(
+ field.widget.render("name", []),
+ (
+ ""
+ )
+ % (self.c1.pk, self.c2.pk, self.c3.pk),
+ )
+
+ def test_custom_choice_iterator_passes_model_to_widget(self):
+ class CustomModelChoiceValue:
+ def __init__(self, value, obj):
+ self.value = value
+ self.obj = obj
+
+ def __str__(self):
+ return str(self.value)
+
+ class CustomModelChoiceIterator(ModelChoiceIterator):
+ def choice(self, obj):
+ value, label = super().choice(obj)
+ return CustomModelChoiceValue(value, obj), label
+
+ class CustomCheckboxSelectMultiple(CheckboxSelectMultiple):
+ def create_option(
+ self, name, value, label, selected, index, subindex=None, attrs=None
+ ):
+ option = super().create_option(
+ name, value, label, selected, index, subindex, attrs
+ )
+ # Modify the HTML based on the object being rendered.
+ c = value.obj
+ option["attrs"]["data-slug"] = c.slug
+ return option
+
+ class CustomModelMultipleChoiceField(forms.ModelMultipleChoiceField):
+ iterator = CustomModelChoiceIterator
+ widget = CustomCheckboxSelectMultiple
+
+ field = CustomModelMultipleChoiceField(Category.objects.order_by("pk"))
+ self.assertHTMLEqual(
+ field.widget.render("name", []),
+ """
+
+ """
+ % (self.c1.pk, self.c2.pk, self.c3.pk),
+ )
+
+ def test_choice_value_hash(self):
+ value_1 = ModelChoiceIteratorValue(self.c1.pk, self.c1)
+ value_2 = ModelChoiceIteratorValue(self.c2.pk, self.c2)
+ self.assertEqual(
+ hash(value_1), hash(ModelChoiceIteratorValue(self.c1.pk, None))
+ )
+ self.assertNotEqual(hash(value_1), hash(value_2))
+
+ def test_choices_not_fetched_when_not_rendering(self):
+ with self.assertNumQueries(1):
+ field = forms.ModelChoiceField(Category.objects.order_by("-name"))
+ self.assertEqual("Entertainment", field.clean(self.c1.pk).name)
+
+ def test_queryset_manager(self):
+ f = forms.ModelChoiceField(Category.objects)
+ self.assertEqual(len(f.choices), 4)
+ self.assertCountEqual(
+ list(f.choices),
+ [
+ ("", "---------"),
+ (self.c1.pk, "Entertainment"),
+ (self.c2.pk, "A test"),
+ (self.c3.pk, "Third"),
+ ],
+ )
+
+ def test_num_queries(self):
+ """
+ Widgets that render multiple subwidgets shouldn't make more than one
+ database query.
+ """
+ categories = Category.objects.all()
+
+ class CategoriesForm(forms.Form):
+ radio = forms.ModelChoiceField(
+ queryset=categories, widget=forms.RadioSelect
+ )
+ checkbox = forms.ModelMultipleChoiceField(
+ queryset=categories, widget=forms.CheckboxSelectMultiple
+ )
+
+ template = Template(
+ "{% for widget in form.checkbox %}{{ widget }}{% endfor %}"
+ "{% for widget in form.radio %}{{ widget }}{% endfor %}"
+ )
+ with self.assertNumQueries(2):
+ template.render(Context({"form": CategoriesForm()}))
diff --git a/testbed/django__django/tests/model_formsets_regress/models.py b/testbed/django__django/tests/model_formsets_regress/models.py
new file mode 100644
index 0000000000000000000000000000000000000000..cc735ad1e70c95501c1a97d455996b65154e85b4
--- /dev/null
+++ b/testbed/django__django/tests/model_formsets_regress/models.py
@@ -0,0 +1,57 @@
+from django.db import models
+
+
+class User(models.Model):
+ username = models.CharField(max_length=12, unique=True)
+ serial = models.IntegerField()
+
+
+class UserSite(models.Model):
+ user = models.ForeignKey(User, models.CASCADE, to_field="username")
+ data = models.IntegerField()
+
+
+class UserProfile(models.Model):
+ user = models.ForeignKey(User, models.CASCADE, unique=True, to_field="username")
+ about = models.TextField()
+
+
+class UserPreferences(models.Model):
+ user = models.OneToOneField(
+ User,
+ models.CASCADE,
+ to_field="username",
+ primary_key=True,
+ )
+ favorite_number = models.IntegerField()
+
+
+class ProfileNetwork(models.Model):
+ profile = models.ForeignKey(UserProfile, models.CASCADE, to_field="user")
+ network = models.IntegerField()
+ identifier = models.IntegerField()
+
+
+class Place(models.Model):
+ name = models.CharField(max_length=50)
+
+
+class Restaurant(Place):
+ pass
+
+
+class Manager(models.Model):
+ restaurant = models.ForeignKey(Restaurant, models.CASCADE)
+ name = models.CharField(max_length=50)
+
+
+class Network(models.Model):
+ name = models.CharField(max_length=15)
+
+
+class Host(models.Model):
+ network = models.ForeignKey(Network, models.CASCADE)
+ hostname = models.CharField(max_length=25)
+
+ def __str__(self):
+ return self.hostname
diff --git a/testbed/django__django/tests/multiple_database/tests.py b/testbed/django__django/tests/multiple_database/tests.py
new file mode 100644
index 0000000000000000000000000000000000000000..337ebae75e66ac2037992488c6240eb055c4a2a3
--- /dev/null
+++ b/testbed/django__django/tests/multiple_database/tests.py
@@ -0,0 +1,2530 @@
+import datetime
+import pickle
+from io import StringIO
+from operator import attrgetter
+from unittest.mock import Mock
+
+from django.contrib.auth.models import User
+from django.contrib.contenttypes.models import ContentType
+from django.core import management
+from django.db import DEFAULT_DB_ALIAS, router, transaction
+from django.db.models import signals
+from django.db.utils import ConnectionRouter
+from django.test import SimpleTestCase, TestCase, override_settings
+
+from .models import Book, Person, Pet, Review, UserProfile
+from .routers import AuthRouter, TestRouter, WriteRouter
+
+
+class QueryTestCase(TestCase):
+ databases = {"default", "other"}
+
+ def test_db_selection(self):
+ "Querysets will use the default database by default"
+ self.assertEqual(Book.objects.db, DEFAULT_DB_ALIAS)
+ self.assertEqual(Book.objects.all().db, DEFAULT_DB_ALIAS)
+
+ self.assertEqual(Book.objects.using("other").db, "other")
+
+ self.assertEqual(Book.objects.db_manager("other").db, "other")
+ self.assertEqual(Book.objects.db_manager("other").all().db, "other")
+
+ def test_default_creation(self):
+ "Objects created on the default database don't leak onto other databases"
+ # Create a book on the default database using create()
+ Book.objects.create(title="Pro Django", published=datetime.date(2008, 12, 16))
+
+ # Create a book on the default database using a save
+ dive = Book()
+ dive.title = "Dive into Python"
+ dive.published = datetime.date(2009, 5, 4)
+ dive.save()
+
+ # Book exists on the default database, but not on other database
+ try:
+ Book.objects.get(title="Pro Django")
+ Book.objects.using("default").get(title="Pro Django")
+ except Book.DoesNotExist:
+ self.fail('"Pro Django" should exist on default database')
+
+ with self.assertRaises(Book.DoesNotExist):
+ Book.objects.using("other").get(title="Pro Django")
+
+ try:
+ Book.objects.get(title="Dive into Python")
+ Book.objects.using("default").get(title="Dive into Python")
+ except Book.DoesNotExist:
+ self.fail('"Dive into Python" should exist on default database')
+
+ with self.assertRaises(Book.DoesNotExist):
+ Book.objects.using("other").get(title="Dive into Python")
+
+ def test_other_creation(self):
+ "Objects created on another database don't leak onto the default database"
+ # Create a book on the second database
+ Book.objects.using("other").create(
+ title="Pro Django", published=datetime.date(2008, 12, 16)
+ )
+
+ # Create a book on the default database using a save
+ dive = Book()
+ dive.title = "Dive into Python"
+ dive.published = datetime.date(2009, 5, 4)
+ dive.save(using="other")
+
+ # Book exists on the default database, but not on other database
+ try:
+ Book.objects.using("other").get(title="Pro Django")
+ except Book.DoesNotExist:
+ self.fail('"Pro Django" should exist on other database')
+
+ with self.assertRaises(Book.DoesNotExist):
+ Book.objects.get(title="Pro Django")
+ with self.assertRaises(Book.DoesNotExist):
+ Book.objects.using("default").get(title="Pro Django")
+
+ try:
+ Book.objects.using("other").get(title="Dive into Python")
+ except Book.DoesNotExist:
+ self.fail('"Dive into Python" should exist on other database')
+
+ with self.assertRaises(Book.DoesNotExist):
+ Book.objects.get(title="Dive into Python")
+ with self.assertRaises(Book.DoesNotExist):
+ Book.objects.using("default").get(title="Dive into Python")
+
+ def test_refresh(self):
+ dive = Book(title="Dive into Python", published=datetime.date(2009, 5, 4))
+ dive.save(using="other")
+ dive2 = Book.objects.using("other").get()
+ dive2.title = "Dive into Python (on default)"
+ dive2.save(using="default")
+ dive.refresh_from_db()
+ self.assertEqual(dive.title, "Dive into Python")
+ dive.refresh_from_db(using="default")
+ self.assertEqual(dive.title, "Dive into Python (on default)")
+ self.assertEqual(dive._state.db, "default")
+
+ def test_refresh_router_instance_hint(self):
+ router = Mock()
+ router.db_for_read.return_value = None
+ book = Book.objects.create(
+ title="Dive Into Python", published=datetime.date(1957, 10, 12)
+ )
+ with self.settings(DATABASE_ROUTERS=[router]):
+ book.refresh_from_db()
+ router.db_for_read.assert_called_once_with(Book, instance=book)
+
+ def test_basic_queries(self):
+ "Queries are constrained to a single database"
+ dive = Book.objects.using("other").create(
+ title="Dive into Python", published=datetime.date(2009, 5, 4)
+ )
+
+ dive = Book.objects.using("other").get(published=datetime.date(2009, 5, 4))
+ self.assertEqual(dive.title, "Dive into Python")
+ with self.assertRaises(Book.DoesNotExist):
+ Book.objects.using("default").get(published=datetime.date(2009, 5, 4))
+
+ dive = Book.objects.using("other").get(title__icontains="dive")
+ self.assertEqual(dive.title, "Dive into Python")
+ with self.assertRaises(Book.DoesNotExist):
+ Book.objects.using("default").get(title__icontains="dive")
+
+ dive = Book.objects.using("other").get(title__iexact="dive INTO python")
+ self.assertEqual(dive.title, "Dive into Python")
+ with self.assertRaises(Book.DoesNotExist):
+ Book.objects.using("default").get(title__iexact="dive INTO python")
+
+ dive = Book.objects.using("other").get(published__year=2009)
+ self.assertEqual(dive.title, "Dive into Python")
+ self.assertEqual(dive.published, datetime.date(2009, 5, 4))
+ with self.assertRaises(Book.DoesNotExist):
+ Book.objects.using("default").get(published__year=2009)
+
+ years = Book.objects.using("other").dates("published", "year")
+ self.assertEqual([o.year for o in years], [2009])
+ years = Book.objects.using("default").dates("published", "year")
+ self.assertEqual([o.year for o in years], [])
+
+ months = Book.objects.using("other").dates("published", "month")
+ self.assertEqual([o.month for o in months], [5])
+ months = Book.objects.using("default").dates("published", "month")
+ self.assertEqual([o.month for o in months], [])
+
+ def test_m2m_separation(self):
+ "M2M fields are constrained to a single database"
+ # Create a book and author on the default database
+ pro = Book.objects.create(
+ title="Pro Django", published=datetime.date(2008, 12, 16)
+ )
+
+ marty = Person.objects.create(name="Marty Alchin")
+
+ # Create a book and author on the other database
+ dive = Book.objects.using("other").create(
+ title="Dive into Python", published=datetime.date(2009, 5, 4)
+ )
+
+ mark = Person.objects.using("other").create(name="Mark Pilgrim")
+
+ # Save the author relations
+ pro.authors.set([marty])
+ dive.authors.set([mark])
+
+ # Inspect the m2m tables directly.
+ # There should be 1 entry in each database
+ self.assertEqual(Book.authors.through.objects.using("default").count(), 1)
+ self.assertEqual(Book.authors.through.objects.using("other").count(), 1)
+
+ # Queries work across m2m joins
+ self.assertEqual(
+ list(
+ Book.objects.using("default")
+ .filter(authors__name="Marty Alchin")
+ .values_list("title", flat=True)
+ ),
+ ["Pro Django"],
+ )
+ self.assertEqual(
+ list(
+ Book.objects.using("other")
+ .filter(authors__name="Marty Alchin")
+ .values_list("title", flat=True)
+ ),
+ [],
+ )
+
+ self.assertEqual(
+ list(
+ Book.objects.using("default")
+ .filter(authors__name="Mark Pilgrim")
+ .values_list("title", flat=True)
+ ),
+ [],
+ )
+ self.assertEqual(
+ list(
+ Book.objects.using("other")
+ .filter(authors__name="Mark Pilgrim")
+ .values_list("title", flat=True)
+ ),
+ ["Dive into Python"],
+ )
+
+ # Reget the objects to clear caches
+ dive = Book.objects.using("other").get(title="Dive into Python")
+ mark = Person.objects.using("other").get(name="Mark Pilgrim")
+
+ # Retrieve related object by descriptor. Related objects should be
+ # database-bound.
+ self.assertEqual(
+ list(dive.authors.values_list("name", flat=True)), ["Mark Pilgrim"]
+ )
+
+ self.assertEqual(
+ list(mark.book_set.values_list("title", flat=True)),
+ ["Dive into Python"],
+ )
+
+ def test_m2m_forward_operations(self):
+ "M2M forward manipulations are all constrained to a single DB"
+ # Create a book and author on the other database
+ dive = Book.objects.using("other").create(
+ title="Dive into Python", published=datetime.date(2009, 5, 4)
+ )
+ mark = Person.objects.using("other").create(name="Mark Pilgrim")
+
+ # Save the author relations
+ dive.authors.set([mark])
+
+ # Add a second author
+ john = Person.objects.using("other").create(name="John Smith")
+ self.assertEqual(
+ list(
+ Book.objects.using("other")
+ .filter(authors__name="John Smith")
+ .values_list("title", flat=True)
+ ),
+ [],
+ )
+
+ dive.authors.add(john)
+ self.assertEqual(
+ list(
+ Book.objects.using("other")
+ .filter(authors__name="Mark Pilgrim")
+ .values_list("title", flat=True)
+ ),
+ ["Dive into Python"],
+ )
+ self.assertEqual(
+ list(
+ Book.objects.using("other")
+ .filter(authors__name="John Smith")
+ .values_list("title", flat=True)
+ ),
+ ["Dive into Python"],
+ )
+
+ # Remove the second author
+ dive.authors.remove(john)
+ self.assertEqual(
+ list(
+ Book.objects.using("other")
+ .filter(authors__name="Mark Pilgrim")
+ .values_list("title", flat=True)
+ ),
+ ["Dive into Python"],
+ )
+ self.assertEqual(
+ list(
+ Book.objects.using("other")
+ .filter(authors__name="John Smith")
+ .values_list("title", flat=True)
+ ),
+ [],
+ )
+
+ # Clear all authors
+ dive.authors.clear()
+ self.assertEqual(
+ list(
+ Book.objects.using("other")
+ .filter(authors__name="Mark Pilgrim")
+ .values_list("title", flat=True)
+ ),
+ [],
+ )
+ self.assertEqual(
+ list(
+ Book.objects.using("other")
+ .filter(authors__name="John Smith")
+ .values_list("title", flat=True)
+ ),
+ [],
+ )
+
+ # Create an author through the m2m interface
+ dive.authors.create(name="Jane Brown")
+ self.assertEqual(
+ list(
+ Book.objects.using("other")
+ .filter(authors__name="Mark Pilgrim")
+ .values_list("title", flat=True)
+ ),
+ [],
+ )
+ self.assertEqual(
+ list(
+ Book.objects.using("other")
+ .filter(authors__name="Jane Brown")
+ .values_list("title", flat=True)
+ ),
+ ["Dive into Python"],
+ )
+
+ def test_m2m_reverse_operations(self):
+ "M2M reverse manipulations are all constrained to a single DB"
+ # Create a book and author on the other database
+ dive = Book.objects.using("other").create(
+ title="Dive into Python", published=datetime.date(2009, 5, 4)
+ )
+ mark = Person.objects.using("other").create(name="Mark Pilgrim")
+
+ # Save the author relations
+ dive.authors.set([mark])
+
+ # Create a second book on the other database
+ grease = Book.objects.using("other").create(
+ title="Greasemonkey Hacks", published=datetime.date(2005, 11, 1)
+ )
+
+ # Add a books to the m2m
+ mark.book_set.add(grease)
+ self.assertEqual(
+ list(
+ Person.objects.using("other")
+ .filter(book__title="Dive into Python")
+ .values_list("name", flat=True)
+ ),
+ ["Mark Pilgrim"],
+ )
+ self.assertEqual(
+ list(
+ Person.objects.using("other")
+ .filter(book__title="Greasemonkey Hacks")
+ .values_list("name", flat=True)
+ ),
+ ["Mark Pilgrim"],
+ )
+
+ # Remove a book from the m2m
+ mark.book_set.remove(grease)
+ self.assertEqual(
+ list(
+ Person.objects.using("other")
+ .filter(book__title="Dive into Python")
+ .values_list("name", flat=True)
+ ),
+ ["Mark Pilgrim"],
+ )
+ self.assertEqual(
+ list(
+ Person.objects.using("other")
+ .filter(book__title="Greasemonkey Hacks")
+ .values_list("name", flat=True)
+ ),
+ [],
+ )
+
+ # Clear the books associated with mark
+ mark.book_set.clear()
+ self.assertEqual(
+ list(
+ Person.objects.using("other")
+ .filter(book__title="Dive into Python")
+ .values_list("name", flat=True)
+ ),
+ [],
+ )
+ self.assertEqual(
+ list(
+ Person.objects.using("other")
+ .filter(book__title="Greasemonkey Hacks")
+ .values_list("name", flat=True)
+ ),
+ [],
+ )
+
+ # Create a book through the m2m interface
+ mark.book_set.create(
+ title="Dive into HTML5", published=datetime.date(2020, 1, 1)
+ )
+ self.assertEqual(
+ list(
+ Person.objects.using("other")
+ .filter(book__title="Dive into Python")
+ .values_list("name", flat=True)
+ ),
+ [],
+ )
+ self.assertEqual(
+ list(
+ Person.objects.using("other")
+ .filter(book__title="Dive into HTML5")
+ .values_list("name", flat=True)
+ ),
+ ["Mark Pilgrim"],
+ )
+
+ def test_m2m_cross_database_protection(self):
+ "Operations that involve sharing M2M objects across databases raise an error"
+ # Create a book and author on the default database
+ pro = Book.objects.create(
+ title="Pro Django", published=datetime.date(2008, 12, 16)
+ )
+
+ marty = Person.objects.create(name="Marty Alchin")
+
+ # Create a book and author on the other database
+ dive = Book.objects.using("other").create(
+ title="Dive into Python", published=datetime.date(2009, 5, 4)
+ )
+
+ mark = Person.objects.using("other").create(name="Mark Pilgrim")
+ # Set a foreign key set with an object from a different database
+ msg = (
+ 'Cannot assign "": the current database '
+ "router prevents this relation."
+ )
+ with self.assertRaisesMessage(ValueError, msg):
+ with transaction.atomic(using="default"):
+ marty.edited.set([pro, dive])
+
+ # Add to an m2m with an object from a different database
+ msg = (
+ 'Cannot add "": instance is on '
+ 'database "default", value is on database "other"'
+ )
+ with self.assertRaisesMessage(ValueError, msg):
+ with transaction.atomic(using="default"):
+ marty.book_set.add(dive)
+
+ # Set a m2m with an object from a different database
+ with self.assertRaisesMessage(ValueError, msg):
+ with transaction.atomic(using="default"):
+ marty.book_set.set([pro, dive])
+
+ # Add to a reverse m2m with an object from a different database
+ msg = (
+ 'Cannot add "": instance is on '
+ 'database "other", value is on database "default"'
+ )
+ with self.assertRaisesMessage(ValueError, msg):
+ with transaction.atomic(using="other"):
+ dive.authors.add(marty)
+
+ # Set a reverse m2m with an object from a different database
+ with self.assertRaisesMessage(ValueError, msg):
+ with transaction.atomic(using="other"):
+ dive.authors.set([mark, marty])
+
+ def test_m2m_deletion(self):
+ "Cascaded deletions of m2m relations issue queries on the right database"
+ # Create a book and author on the other database
+ dive = Book.objects.using("other").create(
+ title="Dive into Python", published=datetime.date(2009, 5, 4)
+ )
+ mark = Person.objects.using("other").create(name="Mark Pilgrim")
+ dive.authors.set([mark])
+
+ # Check the initial state
+ self.assertEqual(Person.objects.using("default").count(), 0)
+ self.assertEqual(Book.objects.using("default").count(), 0)
+ self.assertEqual(Book.authors.through.objects.using("default").count(), 0)
+
+ self.assertEqual(Person.objects.using("other").count(), 1)
+ self.assertEqual(Book.objects.using("other").count(), 1)
+ self.assertEqual(Book.authors.through.objects.using("other").count(), 1)
+
+ # Delete the object on the other database
+ dive.delete(using="other")
+
+ self.assertEqual(Person.objects.using("default").count(), 0)
+ self.assertEqual(Book.objects.using("default").count(), 0)
+ self.assertEqual(Book.authors.through.objects.using("default").count(), 0)
+
+ # The person still exists ...
+ self.assertEqual(Person.objects.using("other").count(), 1)
+ # ... but the book has been deleted
+ self.assertEqual(Book.objects.using("other").count(), 0)
+ # ... and the relationship object has also been deleted.
+ self.assertEqual(Book.authors.through.objects.using("other").count(), 0)
+
+ # Now try deletion in the reverse direction. Set up the relation again
+ dive = Book.objects.using("other").create(
+ title="Dive into Python", published=datetime.date(2009, 5, 4)
+ )
+ dive.authors.set([mark])
+
+ # Check the initial state
+ self.assertEqual(Person.objects.using("default").count(), 0)
+ self.assertEqual(Book.objects.using("default").count(), 0)
+ self.assertEqual(Book.authors.through.objects.using("default").count(), 0)
+
+ self.assertEqual(Person.objects.using("other").count(), 1)
+ self.assertEqual(Book.objects.using("other").count(), 1)
+ self.assertEqual(Book.authors.through.objects.using("other").count(), 1)
+
+ # Delete the object on the other database
+ mark.delete(using="other")
+
+ self.assertEqual(Person.objects.using("default").count(), 0)
+ self.assertEqual(Book.objects.using("default").count(), 0)
+ self.assertEqual(Book.authors.through.objects.using("default").count(), 0)
+
+ # The person has been deleted ...
+ self.assertEqual(Person.objects.using("other").count(), 0)
+ # ... but the book still exists
+ self.assertEqual(Book.objects.using("other").count(), 1)
+ # ... and the relationship object has been deleted.
+ self.assertEqual(Book.authors.through.objects.using("other").count(), 0)
+
+ def test_foreign_key_separation(self):
+ "FK fields are constrained to a single database"
+ # Create a book and author on the default database
+ pro = Book.objects.create(
+ title="Pro Django", published=datetime.date(2008, 12, 16)
+ )
+
+ george = Person.objects.create(name="George Vilches")
+
+ # Create a book and author on the other database
+ dive = Book.objects.using("other").create(
+ title="Dive into Python", published=datetime.date(2009, 5, 4)
+ )
+ chris = Person.objects.using("other").create(name="Chris Mills")
+
+ # Save the author's favorite books
+ pro.editor = george
+ pro.save()
+
+ dive.editor = chris
+ dive.save()
+
+ pro = Book.objects.using("default").get(title="Pro Django")
+ self.assertEqual(pro.editor.name, "George Vilches")
+
+ dive = Book.objects.using("other").get(title="Dive into Python")
+ self.assertEqual(dive.editor.name, "Chris Mills")
+
+ # Queries work across foreign key joins
+ self.assertEqual(
+ list(
+ Person.objects.using("default")
+ .filter(edited__title="Pro Django")
+ .values_list("name", flat=True)
+ ),
+ ["George Vilches"],
+ )
+ self.assertEqual(
+ list(
+ Person.objects.using("other")
+ .filter(edited__title="Pro Django")
+ .values_list("name", flat=True)
+ ),
+ [],
+ )
+
+ self.assertEqual(
+ list(
+ Person.objects.using("default")
+ .filter(edited__title="Dive into Python")
+ .values_list("name", flat=True)
+ ),
+ [],
+ )
+ self.assertEqual(
+ list(
+ Person.objects.using("other")
+ .filter(edited__title="Dive into Python")
+ .values_list("name", flat=True)
+ ),
+ ["Chris Mills"],
+ )
+
+ # Reget the objects to clear caches
+ chris = Person.objects.using("other").get(name="Chris Mills")
+ dive = Book.objects.using("other").get(title="Dive into Python")
+
+ # Retrieve related object by descriptor. Related objects should be
+ # database-bound.
+ self.assertEqual(
+ list(chris.edited.values_list("title", flat=True)), ["Dive into Python"]
+ )
+
+ def test_foreign_key_reverse_operations(self):
+ "FK reverse manipulations are all constrained to a single DB"
+ dive = Book.objects.using("other").create(
+ title="Dive into Python", published=datetime.date(2009, 5, 4)
+ )
+ chris = Person.objects.using("other").create(name="Chris Mills")
+
+ # Save the author relations
+ dive.editor = chris
+ dive.save()
+
+ # Add a second book edited by chris
+ html5 = Book.objects.using("other").create(
+ title="Dive into HTML5", published=datetime.date(2010, 3, 15)
+ )
+ self.assertEqual(
+ list(
+ Person.objects.using("other")
+ .filter(edited__title="Dive into HTML5")
+ .values_list("name", flat=True)
+ ),
+ [],
+ )
+
+ chris.edited.add(html5)
+ self.assertEqual(
+ list(
+ Person.objects.using("other")
+ .filter(edited__title="Dive into HTML5")
+ .values_list("name", flat=True)
+ ),
+ ["Chris Mills"],
+ )
+ self.assertEqual(
+ list(
+ Person.objects.using("other")
+ .filter(edited__title="Dive into Python")
+ .values_list("name", flat=True)
+ ),
+ ["Chris Mills"],
+ )
+
+ # Remove the second editor
+ chris.edited.remove(html5)
+ self.assertEqual(
+ list(
+ Person.objects.using("other")
+ .filter(edited__title="Dive into HTML5")
+ .values_list("name", flat=True)
+ ),
+ [],
+ )
+ self.assertEqual(
+ list(
+ Person.objects.using("other")
+ .filter(edited__title="Dive into Python")
+ .values_list("name", flat=True)
+ ),
+ ["Chris Mills"],
+ )
+
+ # Clear all edited books
+ chris.edited.clear()
+ self.assertEqual(
+ list(
+ Person.objects.using("other")
+ .filter(edited__title="Dive into HTML5")
+ .values_list("name", flat=True)
+ ),
+ [],
+ )
+ self.assertEqual(
+ list(
+ Person.objects.using("other")
+ .filter(edited__title="Dive into Python")
+ .values_list("name", flat=True)
+ ),
+ [],
+ )
+
+ # Create an author through the m2m interface
+ chris.edited.create(
+ title="Dive into Water", published=datetime.date(2010, 3, 15)
+ )
+ self.assertEqual(
+ list(
+ Person.objects.using("other")
+ .filter(edited__title="Dive into HTML5")
+ .values_list("name", flat=True)
+ ),
+ [],
+ )
+ self.assertEqual(
+ list(
+ Person.objects.using("other")
+ .filter(edited__title="Dive into Water")
+ .values_list("name", flat=True)
+ ),
+ ["Chris Mills"],
+ )
+ self.assertEqual(
+ list(
+ Person.objects.using("other")
+ .filter(edited__title="Dive into Python")
+ .values_list("name", flat=True)
+ ),
+ [],
+ )
+
+ def test_foreign_key_cross_database_protection(self):
+ "Operations that involve sharing FK objects across databases raise an error"
+ # Create a book and author on the default database
+ pro = Book.objects.create(
+ title="Pro Django", published=datetime.date(2008, 12, 16)
+ )
+ marty = Person.objects.create(name="Marty Alchin")
+
+ # Create a book and author on the other database
+ dive = Book.objects.using("other").create(
+ title="Dive into Python", published=datetime.date(2009, 5, 4)
+ )
+
+ # Set a foreign key with an object from a different database
+ msg = (
+ 'Cannot assign "": the current database '
+ "router prevents this relation."
+ )
+ with self.assertRaisesMessage(ValueError, msg):
+ dive.editor = marty
+
+ # Set a foreign key set with an object from a different database
+ with self.assertRaisesMessage(ValueError, msg):
+ with transaction.atomic(using="default"):
+ marty.edited.set([pro, dive])
+
+ # Add to a foreign key set with an object from a different database
+ with self.assertRaisesMessage(ValueError, msg):
+ with transaction.atomic(using="default"):
+ marty.edited.add(dive)
+
+ def test_foreign_key_deletion(self):
+ """
+ Cascaded deletions of Foreign Key relations issue queries on the right
+ database.
+ """
+ mark = Person.objects.using("other").create(name="Mark Pilgrim")
+ Pet.objects.using("other").create(name="Fido", owner=mark)
+
+ # Check the initial state
+ self.assertEqual(Person.objects.using("default").count(), 0)
+ self.assertEqual(Pet.objects.using("default").count(), 0)
+
+ self.assertEqual(Person.objects.using("other").count(), 1)
+ self.assertEqual(Pet.objects.using("other").count(), 1)
+
+ # Delete the person object, which will cascade onto the pet
+ mark.delete(using="other")
+
+ self.assertEqual(Person.objects.using("default").count(), 0)
+ self.assertEqual(Pet.objects.using("default").count(), 0)
+
+ # Both the pet and the person have been deleted from the right database
+ self.assertEqual(Person.objects.using("other").count(), 0)
+ self.assertEqual(Pet.objects.using("other").count(), 0)
+
+ def test_foreign_key_validation(self):
+ "ForeignKey.validate() uses the correct database"
+ mickey = Person.objects.using("other").create(name="Mickey")
+ pluto = Pet.objects.using("other").create(name="Pluto", owner=mickey)
+ self.assertIsNone(pluto.full_clean())
+
+ # Any router that accesses `model` in db_for_read() works here.
+ @override_settings(DATABASE_ROUTERS=[AuthRouter()])
+ def test_foreign_key_validation_with_router(self):
+ """
+ ForeignKey.validate() passes `model` to db_for_read() even if
+ model_instance=None.
+ """
+ mickey = Person.objects.create(name="Mickey")
+ owner_field = Pet._meta.get_field("owner")
+ self.assertEqual(owner_field.clean(mickey.pk, None), mickey.pk)
+
+ def test_o2o_separation(self):
+ "OneToOne fields are constrained to a single database"
+ # Create a user and profile on the default database
+ alice = User.objects.db_manager("default").create_user(
+ "alice", "alice@example.com"
+ )
+ alice_profile = UserProfile.objects.using("default").create(
+ user=alice, flavor="chocolate"
+ )
+
+ # Create a user and profile on the other database
+ bob = User.objects.db_manager("other").create_user("bob", "bob@example.com")
+ bob_profile = UserProfile.objects.using("other").create(
+ user=bob, flavor="crunchy frog"
+ )
+
+ # Retrieve related objects; queries should be database constrained
+ alice = User.objects.using("default").get(username="alice")
+ self.assertEqual(alice.userprofile.flavor, "chocolate")
+
+ bob = User.objects.using("other").get(username="bob")
+ self.assertEqual(bob.userprofile.flavor, "crunchy frog")
+
+ # Queries work across joins
+ self.assertEqual(
+ list(
+ User.objects.using("default")
+ .filter(userprofile__flavor="chocolate")
+ .values_list("username", flat=True)
+ ),
+ ["alice"],
+ )
+ self.assertEqual(
+ list(
+ User.objects.using("other")
+ .filter(userprofile__flavor="chocolate")
+ .values_list("username", flat=True)
+ ),
+ [],
+ )
+
+ self.assertEqual(
+ list(
+ User.objects.using("default")
+ .filter(userprofile__flavor="crunchy frog")
+ .values_list("username", flat=True)
+ ),
+ [],
+ )
+ self.assertEqual(
+ list(
+ User.objects.using("other")
+ .filter(userprofile__flavor="crunchy frog")
+ .values_list("username", flat=True)
+ ),
+ ["bob"],
+ )
+
+ # Reget the objects to clear caches
+ alice_profile = UserProfile.objects.using("default").get(flavor="chocolate")
+ bob_profile = UserProfile.objects.using("other").get(flavor="crunchy frog")
+
+ # Retrieve related object by descriptor. Related objects should be
+ # database-bound.
+ self.assertEqual(alice_profile.user.username, "alice")
+ self.assertEqual(bob_profile.user.username, "bob")
+
+ def test_o2o_cross_database_protection(self):
+ "Operations that involve sharing FK objects across databases raise an error"
+ # Create a user and profile on the default database
+ alice = User.objects.db_manager("default").create_user(
+ "alice", "alice@example.com"
+ )
+
+ # Create a user and profile on the other database
+ bob = User.objects.db_manager("other").create_user("bob", "bob@example.com")
+
+ # Set a one-to-one relation with an object from a different database
+ alice_profile = UserProfile.objects.using("default").create(
+ user=alice, flavor="chocolate"
+ )
+ msg = (
+ 'Cannot assign "%r": the current database router prevents this '
+ "relation." % alice_profile
+ )
+ with self.assertRaisesMessage(ValueError, msg):
+ bob.userprofile = alice_profile
+
+ # BUT! if you assign a FK object when the base object hasn't
+ # been saved yet, you implicitly assign the database for the
+ # base object.
+ bob_profile = UserProfile.objects.using("other").create(
+ user=bob, flavor="crunchy frog"
+ )
+
+ new_bob_profile = UserProfile(flavor="spring surprise")
+
+ # assigning a profile requires an explicit pk as the object isn't saved
+ charlie = User(pk=51, username="charlie", email="charlie@example.com")
+ charlie.set_unusable_password()
+
+ # initially, no db assigned
+ self.assertIsNone(new_bob_profile._state.db)
+ self.assertIsNone(charlie._state.db)
+
+ # old object comes from 'other', so the new object is set to use 'other'...
+ new_bob_profile.user = bob
+ charlie.userprofile = bob_profile
+ self.assertEqual(new_bob_profile._state.db, "other")
+ self.assertEqual(charlie._state.db, "other")
+
+ # ... but it isn't saved yet
+ self.assertEqual(
+ list(User.objects.using("other").values_list("username", flat=True)),
+ ["bob"],
+ )
+ self.assertEqual(
+ list(UserProfile.objects.using("other").values_list("flavor", flat=True)),
+ ["crunchy frog"],
+ )
+
+ # When saved (no using required), new objects goes to 'other'
+ charlie.save()
+ bob_profile.save()
+ new_bob_profile.save()
+ self.assertEqual(
+ list(User.objects.using("default").values_list("username", flat=True)),
+ ["alice"],
+ )
+ self.assertEqual(
+ list(User.objects.using("other").values_list("username", flat=True)),
+ ["bob", "charlie"],
+ )
+ self.assertEqual(
+ list(UserProfile.objects.using("default").values_list("flavor", flat=True)),
+ ["chocolate"],
+ )
+ self.assertEqual(
+ list(UserProfile.objects.using("other").values_list("flavor", flat=True)),
+ ["crunchy frog", "spring surprise"],
+ )
+
+ # This also works if you assign the O2O relation in the constructor
+ denise = User.objects.db_manager("other").create_user(
+ "denise", "denise@example.com"
+ )
+ denise_profile = UserProfile(flavor="tofu", user=denise)
+
+ self.assertEqual(denise_profile._state.db, "other")
+ # ... but it isn't saved yet
+ self.assertEqual(
+ list(UserProfile.objects.using("default").values_list("flavor", flat=True)),
+ ["chocolate"],
+ )
+ self.assertEqual(
+ list(UserProfile.objects.using("other").values_list("flavor", flat=True)),
+ ["crunchy frog", "spring surprise"],
+ )
+
+ # When saved, the new profile goes to 'other'
+ denise_profile.save()
+ self.assertEqual(
+ list(UserProfile.objects.using("default").values_list("flavor", flat=True)),
+ ["chocolate"],
+ )
+ self.assertEqual(
+ list(UserProfile.objects.using("other").values_list("flavor", flat=True)),
+ ["crunchy frog", "spring surprise", "tofu"],
+ )
+
+ def test_generic_key_separation(self):
+ "Generic fields are constrained to a single database"
+ # Create a book and author on the default database
+ pro = Book.objects.create(
+ title="Pro Django", published=datetime.date(2008, 12, 16)
+ )
+ review1 = Review.objects.create(source="Python Monthly", content_object=pro)
+
+ # Create a book and author on the other database
+ dive = Book.objects.using("other").create(
+ title="Dive into Python", published=datetime.date(2009, 5, 4)
+ )
+
+ review2 = Review.objects.using("other").create(
+ source="Python Weekly", content_object=dive
+ )
+
+ review1 = Review.objects.using("default").get(source="Python Monthly")
+ self.assertEqual(review1.content_object.title, "Pro Django")
+
+ review2 = Review.objects.using("other").get(source="Python Weekly")
+ self.assertEqual(review2.content_object.title, "Dive into Python")
+
+ # Reget the objects to clear caches
+ dive = Book.objects.using("other").get(title="Dive into Python")
+
+ # Retrieve related object by descriptor. Related objects should be
+ # database-bound.
+ self.assertEqual(
+ list(dive.reviews.values_list("source", flat=True)), ["Python Weekly"]
+ )
+
+ def test_generic_key_reverse_operations(self):
+ "Generic reverse manipulations are all constrained to a single DB"
+ dive = Book.objects.using("other").create(
+ title="Dive into Python", published=datetime.date(2009, 5, 4)
+ )
+ temp = Book.objects.using("other").create(
+ title="Temp", published=datetime.date(2009, 5, 4)
+ )
+ review1 = Review.objects.using("other").create(
+ source="Python Weekly", content_object=dive
+ )
+ review2 = Review.objects.using("other").create(
+ source="Python Monthly", content_object=temp
+ )
+
+ self.assertEqual(
+ list(
+ Review.objects.using("default")
+ .filter(object_id=dive.pk)
+ .values_list("source", flat=True)
+ ),
+ [],
+ )
+ self.assertEqual(
+ list(
+ Review.objects.using("other")
+ .filter(object_id=dive.pk)
+ .values_list("source", flat=True)
+ ),
+ ["Python Weekly"],
+ )
+
+ # Add a second review
+ dive.reviews.add(review2)
+ self.assertEqual(
+ list(
+ Review.objects.using("default")
+ .filter(object_id=dive.pk)
+ .values_list("source", flat=True)
+ ),
+ [],
+ )
+ self.assertEqual(
+ list(
+ Review.objects.using("other")
+ .filter(object_id=dive.pk)
+ .values_list("source", flat=True)
+ ),
+ ["Python Monthly", "Python Weekly"],
+ )
+
+ # Remove the second author
+ dive.reviews.remove(review1)
+ self.assertEqual(
+ list(
+ Review.objects.using("default")
+ .filter(object_id=dive.pk)
+ .values_list("source", flat=True)
+ ),
+ [],
+ )
+ self.assertEqual(
+ list(
+ Review.objects.using("other")
+ .filter(object_id=dive.pk)
+ .values_list("source", flat=True)
+ ),
+ ["Python Monthly"],
+ )
+
+ # Clear all reviews
+ dive.reviews.clear()
+ self.assertEqual(
+ list(
+ Review.objects.using("default")
+ .filter(object_id=dive.pk)
+ .values_list("source", flat=True)
+ ),
+ [],
+ )
+ self.assertEqual(
+ list(
+ Review.objects.using("other")
+ .filter(object_id=dive.pk)
+ .values_list("source", flat=True)
+ ),
+ [],
+ )
+
+ # Create an author through the generic interface
+ dive.reviews.create(source="Python Daily")
+ self.assertEqual(
+ list(
+ Review.objects.using("default")
+ .filter(object_id=dive.pk)
+ .values_list("source", flat=True)
+ ),
+ [],
+ )
+ self.assertEqual(
+ list(
+ Review.objects.using("other")
+ .filter(object_id=dive.pk)
+ .values_list("source", flat=True)
+ ),
+ ["Python Daily"],
+ )
+
+ def test_generic_key_cross_database_protection(self):
+ """
+ Operations that involve sharing generic key objects across databases
+ raise an error.
+ """
+ # Create a book and author on the default database
+ pro = Book.objects.create(
+ title="Pro Django", published=datetime.date(2008, 12, 16)
+ )
+ review1 = Review.objects.create(source="Python Monthly", content_object=pro)
+
+ # Create a book and author on the other database
+ dive = Book.objects.using("other").create(
+ title="Dive into Python", published=datetime.date(2009, 5, 4)
+ )
+
+ Review.objects.using("other").create(
+ source="Python Weekly", content_object=dive
+ )
+
+ # Set a foreign key with an object from a different database
+ msg = (
+ 'Cannot assign "": the '
+ "current database router prevents this relation."
+ )
+ with self.assertRaisesMessage(ValueError, msg):
+ review1.content_object = dive
+
+ # Add to a foreign key set with an object from a different database
+ msg = (
+ " instance isn't saved. "
+ "Use bulk=False or save the object first."
+ )
+ with self.assertRaisesMessage(ValueError, msg):
+ with transaction.atomic(using="other"):
+ dive.reviews.add(review1)
+
+ # BUT! if you assign a FK object when the base object hasn't
+ # been saved yet, you implicitly assign the database for the
+ # base object.
+ review3 = Review(source="Python Daily")
+ # initially, no db assigned
+ self.assertIsNone(review3._state.db)
+
+ # Dive comes from 'other', so review3 is set to use 'other'...
+ review3.content_object = dive
+ self.assertEqual(review3._state.db, "other")
+ # ... but it isn't saved yet
+ self.assertEqual(
+ list(
+ Review.objects.using("default")
+ .filter(object_id=pro.pk)
+ .values_list("source", flat=True)
+ ),
+ ["Python Monthly"],
+ )
+ self.assertEqual(
+ list(
+ Review.objects.using("other")
+ .filter(object_id=dive.pk)
+ .values_list("source", flat=True)
+ ),
+ ["Python Weekly"],
+ )
+
+ # When saved, John goes to 'other'
+ review3.save()
+ self.assertEqual(
+ list(
+ Review.objects.using("default")
+ .filter(object_id=pro.pk)
+ .values_list("source", flat=True)
+ ),
+ ["Python Monthly"],
+ )
+ self.assertEqual(
+ list(
+ Review.objects.using("other")
+ .filter(object_id=dive.pk)
+ .values_list("source", flat=True)
+ ),
+ ["Python Daily", "Python Weekly"],
+ )
+
+ def test_generic_key_deletion(self):
+ """
+ Cascaded deletions of Generic Key relations issue queries on the right
+ database.
+ """
+ dive = Book.objects.using("other").create(
+ title="Dive into Python", published=datetime.date(2009, 5, 4)
+ )
+ Review.objects.using("other").create(
+ source="Python Weekly", content_object=dive
+ )
+
+ # Check the initial state
+ self.assertEqual(Book.objects.using("default").count(), 0)
+ self.assertEqual(Review.objects.using("default").count(), 0)
+
+ self.assertEqual(Book.objects.using("other").count(), 1)
+ self.assertEqual(Review.objects.using("other").count(), 1)
+
+ # Delete the Book object, which will cascade onto the pet
+ dive.delete(using="other")
+
+ self.assertEqual(Book.objects.using("default").count(), 0)
+ self.assertEqual(Review.objects.using("default").count(), 0)
+
+ # Both the pet and the person have been deleted from the right database
+ self.assertEqual(Book.objects.using("other").count(), 0)
+ self.assertEqual(Review.objects.using("other").count(), 0)
+
+ def test_ordering(self):
+ "get_next_by_XXX commands stick to a single database"
+ Book.objects.create(title="Pro Django", published=datetime.date(2008, 12, 16))
+ dive = Book.objects.using("other").create(
+ title="Dive into Python", published=datetime.date(2009, 5, 4)
+ )
+ learn = Book.objects.using("other").create(
+ title="Learning Python", published=datetime.date(2008, 7, 16)
+ )
+
+ self.assertEqual(learn.get_next_by_published().title, "Dive into Python")
+ self.assertEqual(dive.get_previous_by_published().title, "Learning Python")
+
+ def test_raw(self):
+ "test the raw() method across databases"
+ dive = Book.objects.using("other").create(
+ title="Dive into Python", published=datetime.date(2009, 5, 4)
+ )
+ val = Book.objects.db_manager("other").raw(
+ "SELECT id FROM multiple_database_book"
+ )
+ self.assertQuerySetEqual(val, [dive.pk], attrgetter("pk"))
+
+ val = Book.objects.raw("SELECT id FROM multiple_database_book").using("other")
+ self.assertQuerySetEqual(val, [dive.pk], attrgetter("pk"))
+
+ def test_select_related(self):
+ """
+ Database assignment is retained if an object is retrieved with
+ select_related().
+ """
+ # Create a book and author on the other database
+ mark = Person.objects.using("other").create(name="Mark Pilgrim")
+ Book.objects.using("other").create(
+ title="Dive into Python",
+ published=datetime.date(2009, 5, 4),
+ editor=mark,
+ )
+
+ # Retrieve the Person using select_related()
+ book = (
+ Book.objects.using("other")
+ .select_related("editor")
+ .get(title="Dive into Python")
+ )
+
+ # The editor instance should have a db state
+ self.assertEqual(book.editor._state.db, "other")
+
+ def test_subquery(self):
+ """Make sure as_sql works with subqueries and primary/replica."""
+ sub = Person.objects.using("other").filter(name="fff")
+ qs = Book.objects.filter(editor__in=sub)
+
+ # When you call __str__ on the query object, it doesn't know about using
+ # so it falls back to the default. If the subquery explicitly uses a
+ # different database, an error should be raised.
+ msg = (
+ "Subqueries aren't allowed across different databases. Force the "
+ "inner query to be evaluated using `list(inner_query)`."
+ )
+ with self.assertRaisesMessage(ValueError, msg):
+ str(qs.query)
+
+ # Evaluating the query shouldn't work, either
+ with self.assertRaisesMessage(ValueError, msg):
+ for obj in qs:
+ pass
+
+ def test_related_manager(self):
+ "Related managers return managers, not querysets"
+ mark = Person.objects.using("other").create(name="Mark Pilgrim")
+
+ # extra_arg is removed by the BookManager's implementation of
+ # create(); but the BookManager's implementation won't get called
+ # unless edited returns a Manager, not a queryset
+ mark.book_set.create(
+ title="Dive into Python",
+ published=datetime.date(2009, 5, 4),
+ extra_arg=True,
+ )
+ mark.book_set.get_or_create(
+ title="Dive into Python",
+ published=datetime.date(2009, 5, 4),
+ extra_arg=True,
+ )
+ mark.edited.create(
+ title="Dive into Water", published=datetime.date(2009, 5, 4), extra_arg=True
+ )
+ mark.edited.get_or_create(
+ title="Dive into Water", published=datetime.date(2009, 5, 4), extra_arg=True
+ )
+
+
+class ConnectionRouterTestCase(SimpleTestCase):
+ @override_settings(
+ DATABASE_ROUTERS=[
+ "multiple_database.tests.TestRouter",
+ "multiple_database.tests.WriteRouter",
+ ]
+ )
+ def test_router_init_default(self):
+ connection_router = ConnectionRouter()
+ self.assertEqual(
+ [r.__class__.__name__ for r in connection_router.routers],
+ ["TestRouter", "WriteRouter"],
+ )
+
+ def test_router_init_arg(self):
+ connection_router = ConnectionRouter(
+ [
+ "multiple_database.tests.TestRouter",
+ "multiple_database.tests.WriteRouter",
+ ]
+ )
+ self.assertEqual(
+ [r.__class__.__name__ for r in connection_router.routers],
+ ["TestRouter", "WriteRouter"],
+ )
+
+ # Init with instances instead of strings
+ connection_router = ConnectionRouter([TestRouter(), WriteRouter()])
+ self.assertEqual(
+ [r.__class__.__name__ for r in connection_router.routers],
+ ["TestRouter", "WriteRouter"],
+ )
+
+
+# Make the 'other' database appear to be a replica of the 'default'
+@override_settings(DATABASE_ROUTERS=[TestRouter()])
+class RouterTestCase(TestCase):
+ databases = {"default", "other"}
+
+ def test_db_selection(self):
+ "Querysets obey the router for db suggestions"
+ self.assertEqual(Book.objects.db, "other")
+ self.assertEqual(Book.objects.all().db, "other")
+
+ self.assertEqual(Book.objects.using("default").db, "default")
+
+ self.assertEqual(Book.objects.db_manager("default").db, "default")
+ self.assertEqual(Book.objects.db_manager("default").all().db, "default")
+
+ def test_migrate_selection(self):
+ "Synchronization behavior is predictable"
+
+ self.assertTrue(router.allow_migrate_model("default", User))
+ self.assertTrue(router.allow_migrate_model("default", Book))
+
+ self.assertTrue(router.allow_migrate_model("other", User))
+ self.assertTrue(router.allow_migrate_model("other", Book))
+
+ with override_settings(DATABASE_ROUTERS=[TestRouter(), AuthRouter()]):
+ # Add the auth router to the chain. TestRouter is a universal
+ # synchronizer, so it should have no effect.
+ self.assertTrue(router.allow_migrate_model("default", User))
+ self.assertTrue(router.allow_migrate_model("default", Book))
+
+ self.assertTrue(router.allow_migrate_model("other", User))
+ self.assertTrue(router.allow_migrate_model("other", Book))
+
+ with override_settings(DATABASE_ROUTERS=[AuthRouter(), TestRouter()]):
+ # Now check what happens if the router order is reversed.
+ self.assertFalse(router.allow_migrate_model("default", User))
+ self.assertTrue(router.allow_migrate_model("default", Book))
+
+ self.assertTrue(router.allow_migrate_model("other", User))
+ self.assertTrue(router.allow_migrate_model("other", Book))
+
+ def test_partial_router(self):
+ "A router can choose to implement a subset of methods"
+ dive = Book.objects.using("other").create(
+ title="Dive into Python", published=datetime.date(2009, 5, 4)
+ )
+
+ # First check the baseline behavior.
+
+ self.assertEqual(router.db_for_read(User), "other")
+ self.assertEqual(router.db_for_read(Book), "other")
+
+ self.assertEqual(router.db_for_write(User), "default")
+ self.assertEqual(router.db_for_write(Book), "default")
+
+ self.assertTrue(router.allow_relation(dive, dive))
+
+ self.assertTrue(router.allow_migrate_model("default", User))
+ self.assertTrue(router.allow_migrate_model("default", Book))
+
+ with override_settings(
+ DATABASE_ROUTERS=[WriteRouter(), AuthRouter(), TestRouter()]
+ ):
+ self.assertEqual(router.db_for_read(User), "default")
+ self.assertEqual(router.db_for_read(Book), "other")
+
+ self.assertEqual(router.db_for_write(User), "writer")
+ self.assertEqual(router.db_for_write(Book), "writer")
+
+ self.assertTrue(router.allow_relation(dive, dive))
+
+ self.assertFalse(router.allow_migrate_model("default", User))
+ self.assertTrue(router.allow_migrate_model("default", Book))
+
+ def test_database_routing(self):
+ marty = Person.objects.using("default").create(name="Marty Alchin")
+ pro = Book.objects.using("default").create(
+ title="Pro Django",
+ published=datetime.date(2008, 12, 16),
+ editor=marty,
+ )
+ pro.authors.set([marty])
+
+ # Create a book and author on the other database
+ Book.objects.using("other").create(
+ title="Dive into Python", published=datetime.date(2009, 5, 4)
+ )
+
+ # An update query will be routed to the default database
+ Book.objects.filter(title="Pro Django").update(pages=200)
+
+ with self.assertRaises(Book.DoesNotExist):
+ # By default, the get query will be directed to 'other'
+ Book.objects.get(title="Pro Django")
+
+ # But the same query issued explicitly at a database will work.
+ pro = Book.objects.using("default").get(title="Pro Django")
+
+ # The update worked.
+ self.assertEqual(pro.pages, 200)
+
+ # An update query with an explicit using clause will be routed
+ # to the requested database.
+ Book.objects.using("other").filter(title="Dive into Python").update(pages=300)
+ self.assertEqual(Book.objects.get(title="Dive into Python").pages, 300)
+
+ # Related object queries stick to the same database
+ # as the original object, regardless of the router
+ self.assertEqual(
+ list(pro.authors.values_list("name", flat=True)), ["Marty Alchin"]
+ )
+ self.assertEqual(pro.editor.name, "Marty Alchin")
+
+ # get_or_create is a special case. The get needs to be targeted at
+ # the write database in order to avoid potential transaction
+ # consistency problems
+ book, created = Book.objects.get_or_create(title="Pro Django")
+ self.assertFalse(created)
+
+ book, created = Book.objects.get_or_create(
+ title="Dive Into Python", defaults={"published": datetime.date(2009, 5, 4)}
+ )
+ self.assertTrue(created)
+
+ # Check the head count of objects
+ self.assertEqual(Book.objects.using("default").count(), 2)
+ self.assertEqual(Book.objects.using("other").count(), 1)
+ # If a database isn't specified, the read database is used
+ self.assertEqual(Book.objects.count(), 1)
+
+ # A delete query will also be routed to the default database
+ Book.objects.filter(pages__gt=150).delete()
+
+ # The default database has lost the book.
+ self.assertEqual(Book.objects.using("default").count(), 1)
+ self.assertEqual(Book.objects.using("other").count(), 1)
+
+ def test_invalid_set_foreign_key_assignment(self):
+ marty = Person.objects.using("default").create(name="Marty Alchin")
+ dive = Book.objects.using("other").create(
+ title="Dive into Python",
+ published=datetime.date(2009, 5, 4),
+ )
+ # Set a foreign key set with an object from a different database
+ msg = (
+ " instance isn't saved. Use bulk=False or save the "
+ "object first."
+ )
+ with self.assertRaisesMessage(ValueError, msg):
+ marty.edited.set([dive])
+
+ def test_foreign_key_cross_database_protection(self):
+ "Foreign keys can cross databases if they two databases have a common source"
+ # Create a book and author on the default database
+ pro = Book.objects.using("default").create(
+ title="Pro Django", published=datetime.date(2008, 12, 16)
+ )
+
+ marty = Person.objects.using("default").create(name="Marty Alchin")
+
+ # Create a book and author on the other database
+ dive = Book.objects.using("other").create(
+ title="Dive into Python", published=datetime.date(2009, 5, 4)
+ )
+
+ mark = Person.objects.using("other").create(name="Mark Pilgrim")
+
+ # Set a foreign key with an object from a different database
+ dive.editor = marty
+
+ # Database assignments of original objects haven't changed...
+ self.assertEqual(marty._state.db, "default")
+ self.assertEqual(pro._state.db, "default")
+ self.assertEqual(dive._state.db, "other")
+ self.assertEqual(mark._state.db, "other")
+
+ # ... but they will when the affected object is saved.
+ dive.save()
+ self.assertEqual(dive._state.db, "default")
+
+ # ...and the source database now has a copy of any object saved
+ Book.objects.using("default").get(title="Dive into Python").delete()
+
+ # This isn't a real primary/replica database, so restore the original from other
+ dive = Book.objects.using("other").get(title="Dive into Python")
+ self.assertEqual(dive._state.db, "other")
+
+ # Set a foreign key set with an object from a different database
+ marty.edited.set([pro, dive], bulk=False)
+
+ # Assignment implies a save, so database assignments of original
+ # objects have changed...
+ self.assertEqual(marty._state.db, "default")
+ self.assertEqual(pro._state.db, "default")
+ self.assertEqual(dive._state.db, "default")
+ self.assertEqual(mark._state.db, "other")
+
+ # ...and the source database now has a copy of any object saved
+ Book.objects.using("default").get(title="Dive into Python").delete()
+
+ # This isn't a real primary/replica database, so restore the original from other
+ dive = Book.objects.using("other").get(title="Dive into Python")
+ self.assertEqual(dive._state.db, "other")
+
+ # Add to a foreign key set with an object from a different database
+ marty.edited.add(dive, bulk=False)
+
+ # Add implies a save, so database assignments of original objects have
+ # changed...
+ self.assertEqual(marty._state.db, "default")
+ self.assertEqual(pro._state.db, "default")
+ self.assertEqual(dive._state.db, "default")
+ self.assertEqual(mark._state.db, "other")
+
+ # ...and the source database now has a copy of any object saved
+ Book.objects.using("default").get(title="Dive into Python").delete()
+
+ # This isn't a real primary/replica database, so restore the original from other
+ dive = Book.objects.using("other").get(title="Dive into Python")
+
+ # If you assign a FK object when the base object hasn't
+ # been saved yet, you implicitly assign the database for the
+ # base object.
+ chris = Person(name="Chris Mills")
+ html5 = Book(title="Dive into HTML5", published=datetime.date(2010, 3, 15))
+ # initially, no db assigned
+ self.assertIsNone(chris._state.db)
+ self.assertIsNone(html5._state.db)
+
+ # old object comes from 'other', so the new object is set to use the
+ # source of 'other'...
+ self.assertEqual(dive._state.db, "other")
+ chris.save()
+ dive.editor = chris
+ html5.editor = mark
+
+ self.assertEqual(dive._state.db, "other")
+ self.assertEqual(mark._state.db, "other")
+ self.assertEqual(chris._state.db, "default")
+ self.assertEqual(html5._state.db, "default")
+
+ # This also works if you assign the FK in the constructor
+ water = Book(
+ title="Dive into Water", published=datetime.date(2001, 1, 1), editor=mark
+ )
+ self.assertEqual(water._state.db, "default")
+
+ # For the remainder of this test, create a copy of 'mark' in the
+ # 'default' database to prevent integrity errors on backends that
+ # don't defer constraints checks until the end of the transaction
+ mark.save(using="default")
+
+ # This moved 'mark' in the 'default' database, move it back in 'other'
+ mark.save(using="other")
+ self.assertEqual(mark._state.db, "other")
+
+ # If you create an object through a FK relation, it will be
+ # written to the write database, even if the original object
+ # was on the read database
+ cheesecake = mark.edited.create(
+ title="Dive into Cheesecake", published=datetime.date(2010, 3, 15)
+ )
+ self.assertEqual(cheesecake._state.db, "default")
+
+ # Same goes for get_or_create, regardless of whether getting or creating
+ cheesecake, created = mark.edited.get_or_create(
+ title="Dive into Cheesecake",
+ published=datetime.date(2010, 3, 15),
+ )
+ self.assertEqual(cheesecake._state.db, "default")
+
+ puddles, created = mark.edited.get_or_create(
+ title="Dive into Puddles", published=datetime.date(2010, 3, 15)
+ )
+ self.assertEqual(puddles._state.db, "default")
+
+ def test_m2m_cross_database_protection(self):
+ "M2M relations can cross databases if the database share a source"
+ # Create books and authors on the inverse to the usual database
+ pro = Book.objects.using("other").create(
+ pk=1, title="Pro Django", published=datetime.date(2008, 12, 16)
+ )
+
+ marty = Person.objects.using("other").create(pk=1, name="Marty Alchin")
+
+ dive = Book.objects.using("default").create(
+ pk=2, title="Dive into Python", published=datetime.date(2009, 5, 4)
+ )
+
+ mark = Person.objects.using("default").create(pk=2, name="Mark Pilgrim")
+
+ # Now save back onto the usual database.
+ # This simulates primary/replica - the objects exist on both database,
+ # but the _state.db is as it is for all other tests.
+ pro.save(using="default")
+ marty.save(using="default")
+ dive.save(using="other")
+ mark.save(using="other")
+
+ # We have 2 of both types of object on both databases
+ self.assertEqual(Book.objects.using("default").count(), 2)
+ self.assertEqual(Book.objects.using("other").count(), 2)
+ self.assertEqual(Person.objects.using("default").count(), 2)
+ self.assertEqual(Person.objects.using("other").count(), 2)
+
+ # Set a m2m set with an object from a different database
+ marty.book_set.set([pro, dive])
+
+ # Database assignments don't change
+ self.assertEqual(marty._state.db, "default")
+ self.assertEqual(pro._state.db, "default")
+ self.assertEqual(dive._state.db, "other")
+ self.assertEqual(mark._state.db, "other")
+
+ # All m2m relations should be saved on the default database
+ self.assertEqual(Book.authors.through.objects.using("default").count(), 2)
+ self.assertEqual(Book.authors.through.objects.using("other").count(), 0)
+
+ # Reset relations
+ Book.authors.through.objects.using("default").delete()
+
+ # Add to an m2m with an object from a different database
+ marty.book_set.add(dive)
+
+ # Database assignments don't change
+ self.assertEqual(marty._state.db, "default")
+ self.assertEqual(pro._state.db, "default")
+ self.assertEqual(dive._state.db, "other")
+ self.assertEqual(mark._state.db, "other")
+
+ # All m2m relations should be saved on the default database
+ self.assertEqual(Book.authors.through.objects.using("default").count(), 1)
+ self.assertEqual(Book.authors.through.objects.using("other").count(), 0)
+
+ # Reset relations
+ Book.authors.through.objects.using("default").delete()
+
+ # Set a reverse m2m with an object from a different database
+ dive.authors.set([mark, marty])
+
+ # Database assignments don't change
+ self.assertEqual(marty._state.db, "default")
+ self.assertEqual(pro._state.db, "default")
+ self.assertEqual(dive._state.db, "other")
+ self.assertEqual(mark._state.db, "other")
+
+ # All m2m relations should be saved on the default database
+ self.assertEqual(Book.authors.through.objects.using("default").count(), 2)
+ self.assertEqual(Book.authors.through.objects.using("other").count(), 0)
+
+ # Reset relations
+ Book.authors.through.objects.using("default").delete()
+
+ self.assertEqual(Book.authors.through.objects.using("default").count(), 0)
+ self.assertEqual(Book.authors.through.objects.using("other").count(), 0)
+
+ # Add to a reverse m2m with an object from a different database
+ dive.authors.add(marty)
+
+ # Database assignments don't change
+ self.assertEqual(marty._state.db, "default")
+ self.assertEqual(pro._state.db, "default")
+ self.assertEqual(dive._state.db, "other")
+ self.assertEqual(mark._state.db, "other")
+
+ # All m2m relations should be saved on the default database
+ self.assertEqual(Book.authors.through.objects.using("default").count(), 1)
+ self.assertEqual(Book.authors.through.objects.using("other").count(), 0)
+
+ # If you create an object through a M2M relation, it will be
+ # written to the write database, even if the original object
+ # was on the read database
+ alice = dive.authors.create(name="Alice", pk=3)
+ self.assertEqual(alice._state.db, "default")
+
+ # Same goes for get_or_create, regardless of whether getting or creating
+ alice, created = dive.authors.get_or_create(name="Alice")
+ self.assertEqual(alice._state.db, "default")
+
+ bob, created = dive.authors.get_or_create(name="Bob", defaults={"pk": 4})
+ self.assertEqual(bob._state.db, "default")
+
+ def test_o2o_cross_database_protection(self):
+ "Operations that involve sharing FK objects across databases raise an error"
+ # Create a user and profile on the default database
+ alice = User.objects.db_manager("default").create_user(
+ "alice", "alice@example.com"
+ )
+
+ # Create a user and profile on the other database
+ bob = User.objects.db_manager("other").create_user("bob", "bob@example.com")
+
+ # Set a one-to-one relation with an object from a different database
+ alice_profile = UserProfile.objects.create(user=alice, flavor="chocolate")
+ bob.userprofile = alice_profile
+
+ # Database assignments of original objects haven't changed...
+ self.assertEqual(alice._state.db, "default")
+ self.assertEqual(alice_profile._state.db, "default")
+ self.assertEqual(bob._state.db, "other")
+
+ # ... but they will when the affected object is saved.
+ bob.save()
+ self.assertEqual(bob._state.db, "default")
+
+ def test_generic_key_cross_database_protection(self):
+ "Generic Key operations can span databases if they share a source"
+ # Create a book and author on the default database
+ pro = Book.objects.using("default").create(
+ title="Pro Django", published=datetime.date(2008, 12, 16)
+ )
+
+ review1 = Review.objects.using("default").create(
+ source="Python Monthly", content_object=pro
+ )
+
+ # Create a book and author on the other database
+ dive = Book.objects.using("other").create(
+ title="Dive into Python", published=datetime.date(2009, 5, 4)
+ )
+
+ review2 = Review.objects.using("other").create(
+ source="Python Weekly", content_object=dive
+ )
+
+ # Set a generic foreign key with an object from a different database
+ review1.content_object = dive
+
+ # Database assignments of original objects haven't changed...
+ self.assertEqual(pro._state.db, "default")
+ self.assertEqual(review1._state.db, "default")
+ self.assertEqual(dive._state.db, "other")
+ self.assertEqual(review2._state.db, "other")
+
+ # ... but they will when the affected object is saved.
+ dive.save()
+ self.assertEqual(review1._state.db, "default")
+ self.assertEqual(dive._state.db, "default")
+
+ # ...and the source database now has a copy of any object saved
+ Book.objects.using("default").get(title="Dive into Python").delete()
+
+ # This isn't a real primary/replica database, so restore the original from other
+ dive = Book.objects.using("other").get(title="Dive into Python")
+ self.assertEqual(dive._state.db, "other")
+
+ # Add to a generic foreign key set with an object from a different database
+ dive.reviews.add(review1)
+
+ # Database assignments of original objects haven't changed...
+ self.assertEqual(pro._state.db, "default")
+ self.assertEqual(review1._state.db, "default")
+ self.assertEqual(dive._state.db, "other")
+ self.assertEqual(review2._state.db, "other")
+
+ # ... but they will when the affected object is saved.
+ dive.save()
+ self.assertEqual(dive._state.db, "default")
+
+ # ...and the source database now has a copy of any object saved
+ Book.objects.using("default").get(title="Dive into Python").delete()
+
+ # BUT! if you assign a FK object when the base object hasn't
+ # been saved yet, you implicitly assign the database for the
+ # base object.
+ review3 = Review(source="Python Daily")
+ # initially, no db assigned
+ self.assertIsNone(review3._state.db)
+
+ # Dive comes from 'other', so review3 is set to use the source of 'other'...
+ review3.content_object = dive
+ self.assertEqual(review3._state.db, "default")
+
+ # If you create an object through a M2M relation, it will be
+ # written to the write database, even if the original object
+ # was on the read database
+ dive = Book.objects.using("other").get(title="Dive into Python")
+ nyt = dive.reviews.create(source="New York Times", content_object=dive)
+ self.assertEqual(nyt._state.db, "default")
+
+ def test_m2m_managers(self):
+ "M2M relations are represented by managers, and can be controlled like managers"
+ pro = Book.objects.using("other").create(
+ pk=1, title="Pro Django", published=datetime.date(2008, 12, 16)
+ )
+
+ marty = Person.objects.using("other").create(pk=1, name="Marty Alchin")
+
+ self.assertEqual(pro.authors.db, "other")
+ self.assertEqual(pro.authors.db_manager("default").db, "default")
+ self.assertEqual(pro.authors.db_manager("default").all().db, "default")
+
+ self.assertEqual(marty.book_set.db, "other")
+ self.assertEqual(marty.book_set.db_manager("default").db, "default")
+ self.assertEqual(marty.book_set.db_manager("default").all().db, "default")
+
+ def test_foreign_key_managers(self):
+ """
+ FK reverse relations are represented by managers, and can be controlled
+ like managers.
+ """
+ marty = Person.objects.using("other").create(pk=1, name="Marty Alchin")
+ Book.objects.using("other").create(
+ pk=1,
+ title="Pro Django",
+ published=datetime.date(2008, 12, 16),
+ editor=marty,
+ )
+ self.assertEqual(marty.edited.db, "other")
+ self.assertEqual(marty.edited.db_manager("default").db, "default")
+ self.assertEqual(marty.edited.db_manager("default").all().db, "default")
+
+ def test_generic_key_managers(self):
+ """
+ Generic key relations are represented by managers, and can be
+ controlled like managers.
+ """
+ pro = Book.objects.using("other").create(
+ title="Pro Django", published=datetime.date(2008, 12, 16)
+ )
+
+ Review.objects.using("other").create(
+ source="Python Monthly", content_object=pro
+ )
+
+ self.assertEqual(pro.reviews.db, "other")
+ self.assertEqual(pro.reviews.db_manager("default").db, "default")
+ self.assertEqual(pro.reviews.db_manager("default").all().db, "default")
+
+ def test_subquery(self):
+ """Make sure as_sql works with subqueries and primary/replica."""
+ # Create a book and author on the other database
+
+ mark = Person.objects.using("other").create(name="Mark Pilgrim")
+ Book.objects.using("other").create(
+ title="Dive into Python",
+ published=datetime.date(2009, 5, 4),
+ editor=mark,
+ )
+
+ sub = Person.objects.filter(name="Mark Pilgrim")
+ qs = Book.objects.filter(editor__in=sub)
+
+ # When you call __str__ on the query object, it doesn't know about using
+ # so it falls back to the default. Don't let routing instructions
+ # force the subquery to an incompatible database.
+ str(qs.query)
+
+ # If you evaluate the query, it should work, running on 'other'
+ self.assertEqual(list(qs.values_list("title", flat=True)), ["Dive into Python"])
+
+ def test_deferred_models(self):
+ mark_def = Person.objects.using("default").create(name="Mark Pilgrim")
+ mark_other = Person.objects.using("other").create(name="Mark Pilgrim")
+ orig_b = Book.objects.using("other").create(
+ title="Dive into Python",
+ published=datetime.date(2009, 5, 4),
+ editor=mark_other,
+ )
+ b = Book.objects.using("other").only("title").get(pk=orig_b.pk)
+ self.assertEqual(b.published, datetime.date(2009, 5, 4))
+ b = Book.objects.using("other").only("title").get(pk=orig_b.pk)
+ b.editor = mark_def
+ b.save(using="default")
+ self.assertEqual(
+ Book.objects.using("default").get(pk=b.pk).published,
+ datetime.date(2009, 5, 4),
+ )
+
+
+@override_settings(DATABASE_ROUTERS=[AuthRouter()])
+class AuthTestCase(TestCase):
+ databases = {"default", "other"}
+
+ def test_auth_manager(self):
+ "The methods on the auth manager obey database hints"
+ # Create one user using default allocation policy
+ User.objects.create_user("alice", "alice@example.com")
+
+ # Create another user, explicitly specifying the database
+ User.objects.db_manager("default").create_user("bob", "bob@example.com")
+
+ # The second user only exists on the other database
+ alice = User.objects.using("other").get(username="alice")
+
+ self.assertEqual(alice.username, "alice")
+ self.assertEqual(alice._state.db, "other")
+
+ with self.assertRaises(User.DoesNotExist):
+ User.objects.using("default").get(username="alice")
+
+ # The second user only exists on the default database
+ bob = User.objects.using("default").get(username="bob")
+
+ self.assertEqual(bob.username, "bob")
+ self.assertEqual(bob._state.db, "default")
+
+ with self.assertRaises(User.DoesNotExist):
+ User.objects.using("other").get(username="bob")
+
+ # That is... there is one user on each database
+ self.assertEqual(User.objects.using("default").count(), 1)
+ self.assertEqual(User.objects.using("other").count(), 1)
+
+ def test_dumpdata(self):
+ "dumpdata honors allow_migrate restrictions on the router"
+ User.objects.create_user("alice", "alice@example.com")
+ User.objects.db_manager("default").create_user("bob", "bob@example.com")
+
+ # dumping the default database doesn't try to include auth because
+ # allow_migrate prohibits auth on default
+ new_io = StringIO()
+ management.call_command(
+ "dumpdata", "auth", format="json", database="default", stdout=new_io
+ )
+ command_output = new_io.getvalue().strip()
+ self.assertEqual(command_output, "[]")
+
+ # dumping the other database does include auth
+ new_io = StringIO()
+ management.call_command(
+ "dumpdata", "auth", format="json", database="other", stdout=new_io
+ )
+ command_output = new_io.getvalue().strip()
+ self.assertIn('"email": "alice@example.com"', command_output)
+
+
+class AntiPetRouter:
+ # A router that only expresses an opinion on migrate,
+ # passing pets to the 'other' database
+
+ def allow_migrate(self, db, app_label, model_name=None, **hints):
+ if db == "other":
+ return model_name == "pet"
+ else:
+ return model_name != "pet"
+
+
+class FixtureTestCase(TestCase):
+ databases = {"default", "other"}
+ fixtures = ["multidb-common", "multidb"]
+
+ @override_settings(DATABASE_ROUTERS=[AntiPetRouter()])
+ def test_fixture_loading(self):
+ "Multi-db fixtures are loaded correctly"
+ # "Pro Django" exists on the default database, but not on other database
+ Book.objects.get(title="Pro Django")
+ Book.objects.using("default").get(title="Pro Django")
+
+ with self.assertRaises(Book.DoesNotExist):
+ Book.objects.using("other").get(title="Pro Django")
+
+ # "Dive into Python" exists on the default database, but not on other database
+ Book.objects.using("other").get(title="Dive into Python")
+
+ with self.assertRaises(Book.DoesNotExist):
+ Book.objects.get(title="Dive into Python")
+ with self.assertRaises(Book.DoesNotExist):
+ Book.objects.using("default").get(title="Dive into Python")
+
+ # "Definitive Guide" exists on the both databases
+ Book.objects.get(title="The Definitive Guide to Django")
+ Book.objects.using("default").get(title="The Definitive Guide to Django")
+ Book.objects.using("other").get(title="The Definitive Guide to Django")
+
+ @override_settings(DATABASE_ROUTERS=[AntiPetRouter()])
+ def test_pseudo_empty_fixtures(self):
+ """
+ A fixture can contain entries, but lead to nothing in the database;
+ this shouldn't raise an error (#14068).
+ """
+ new_io = StringIO()
+ management.call_command("loaddata", "pets", stdout=new_io, stderr=new_io)
+ command_output = new_io.getvalue().strip()
+ # No objects will actually be loaded
+ self.assertEqual(
+ command_output, "Installed 0 object(s) (of 2) from 1 fixture(s)"
+ )
+
+
+class PickleQuerySetTestCase(TestCase):
+ databases = {"default", "other"}
+
+ def test_pickling(self):
+ for db in self.databases:
+ Book.objects.using(db).create(
+ title="Dive into Python", published=datetime.date(2009, 5, 4)
+ )
+ qs = Book.objects.all()
+ self.assertEqual(qs.db, pickle.loads(pickle.dumps(qs)).db)
+
+
+class DatabaseReceiver:
+ """
+ Used in the tests for the database argument in signals (#13552)
+ """
+
+ def __call__(self, signal, sender, **kwargs):
+ self._database = kwargs["using"]
+
+
+class WriteToOtherRouter:
+ """
+ A router that sends all writes to the other database.
+ """
+
+ def db_for_write(self, model, **hints):
+ return "other"
+
+
+class SignalTests(TestCase):
+ databases = {"default", "other"}
+
+ def override_router(self):
+ return override_settings(DATABASE_ROUTERS=[WriteToOtherRouter()])
+
+ def test_database_arg_save_and_delete(self):
+ """
+ The pre/post_save signal contains the correct database.
+ """
+ # Make some signal receivers
+ pre_save_receiver = DatabaseReceiver()
+ post_save_receiver = DatabaseReceiver()
+ pre_delete_receiver = DatabaseReceiver()
+ post_delete_receiver = DatabaseReceiver()
+ # Make model and connect receivers
+ signals.pre_save.connect(sender=Person, receiver=pre_save_receiver)
+ signals.post_save.connect(sender=Person, receiver=post_save_receiver)
+ signals.pre_delete.connect(sender=Person, receiver=pre_delete_receiver)
+ signals.post_delete.connect(sender=Person, receiver=post_delete_receiver)
+ p = Person.objects.create(name="Darth Vader")
+ # Save and test receivers got calls
+ p.save()
+ self.assertEqual(pre_save_receiver._database, DEFAULT_DB_ALIAS)
+ self.assertEqual(post_save_receiver._database, DEFAULT_DB_ALIAS)
+ # Delete, and test
+ p.delete()
+ self.assertEqual(pre_delete_receiver._database, DEFAULT_DB_ALIAS)
+ self.assertEqual(post_delete_receiver._database, DEFAULT_DB_ALIAS)
+ # Save again to a different database
+ p.save(using="other")
+ self.assertEqual(pre_save_receiver._database, "other")
+ self.assertEqual(post_save_receiver._database, "other")
+ # Delete, and test
+ p.delete(using="other")
+ self.assertEqual(pre_delete_receiver._database, "other")
+ self.assertEqual(post_delete_receiver._database, "other")
+
+ signals.pre_save.disconnect(sender=Person, receiver=pre_save_receiver)
+ signals.post_save.disconnect(sender=Person, receiver=post_save_receiver)
+ signals.pre_delete.disconnect(sender=Person, receiver=pre_delete_receiver)
+ signals.post_delete.disconnect(sender=Person, receiver=post_delete_receiver)
+
+ def test_database_arg_m2m(self):
+ """
+ The m2m_changed signal has a correct database arg.
+ """
+ # Make a receiver
+ receiver = DatabaseReceiver()
+ # Connect it
+ signals.m2m_changed.connect(receiver=receiver)
+
+ # Create the models that will be used for the tests
+ b = Book.objects.create(
+ title="Pro Django", published=datetime.date(2008, 12, 16)
+ )
+ p = Person.objects.create(name="Marty Alchin")
+
+ # Create a copy of the models on the 'other' database to prevent
+ # integrity errors on backends that don't defer constraints checks
+ Book.objects.using("other").create(
+ pk=b.pk, title=b.title, published=b.published
+ )
+ Person.objects.using("other").create(pk=p.pk, name=p.name)
+
+ # Test addition
+ b.authors.add(p)
+ self.assertEqual(receiver._database, DEFAULT_DB_ALIAS)
+ with self.override_router():
+ b.authors.add(p)
+ self.assertEqual(receiver._database, "other")
+
+ # Test removal
+ b.authors.remove(p)
+ self.assertEqual(receiver._database, DEFAULT_DB_ALIAS)
+ with self.override_router():
+ b.authors.remove(p)
+ self.assertEqual(receiver._database, "other")
+
+ # Test addition in reverse
+ p.book_set.add(b)
+ self.assertEqual(receiver._database, DEFAULT_DB_ALIAS)
+ with self.override_router():
+ p.book_set.add(b)
+ self.assertEqual(receiver._database, "other")
+
+ # Test clearing
+ b.authors.clear()
+ self.assertEqual(receiver._database, DEFAULT_DB_ALIAS)
+ with self.override_router():
+ b.authors.clear()
+ self.assertEqual(receiver._database, "other")
+
+
+class AttributeErrorRouter:
+ "A router to test the exception handling of ConnectionRouter"
+
+ def db_for_read(self, model, **hints):
+ raise AttributeError
+
+ def db_for_write(self, model, **hints):
+ raise AttributeError
+
+
+class RouterAttributeErrorTestCase(TestCase):
+ databases = {"default", "other"}
+
+ def override_router(self):
+ return override_settings(DATABASE_ROUTERS=[AttributeErrorRouter()])
+
+ def test_attribute_error_read(self):
+ "The AttributeError from AttributeErrorRouter bubbles up"
+ b = Book.objects.create(
+ title="Pro Django", published=datetime.date(2008, 12, 16)
+ )
+ with self.override_router():
+ with self.assertRaises(AttributeError):
+ Book.objects.get(pk=b.pk)
+
+ def test_attribute_error_save(self):
+ "The AttributeError from AttributeErrorRouter bubbles up"
+ dive = Book()
+ dive.title = "Dive into Python"
+ dive.published = datetime.date(2009, 5, 4)
+ with self.override_router():
+ with self.assertRaises(AttributeError):
+ dive.save()
+
+ def test_attribute_error_delete(self):
+ "The AttributeError from AttributeErrorRouter bubbles up"
+ b = Book.objects.create(
+ title="Pro Django", published=datetime.date(2008, 12, 16)
+ )
+ p = Person.objects.create(name="Marty Alchin")
+ b.authors.set([p])
+ b.editor = p
+ with self.override_router():
+ with self.assertRaises(AttributeError):
+ b.delete()
+
+ def test_attribute_error_m2m(self):
+ "The AttributeError from AttributeErrorRouter bubbles up"
+ b = Book.objects.create(
+ title="Pro Django", published=datetime.date(2008, 12, 16)
+ )
+ p = Person.objects.create(name="Marty Alchin")
+ with self.override_router():
+ with self.assertRaises(AttributeError):
+ b.authors.set([p])
+
+
+class ModelMetaRouter:
+ "A router to ensure model arguments are real model classes"
+
+ def db_for_write(self, model, **hints):
+ if not hasattr(model, "_meta"):
+ raise ValueError
+
+
+@override_settings(DATABASE_ROUTERS=[ModelMetaRouter()])
+class RouterModelArgumentTestCase(TestCase):
+ databases = {"default", "other"}
+
+ def test_m2m_collection(self):
+ b = Book.objects.create(
+ title="Pro Django", published=datetime.date(2008, 12, 16)
+ )
+
+ p = Person.objects.create(name="Marty Alchin")
+ # test add
+ b.authors.add(p)
+ # test remove
+ b.authors.remove(p)
+ # test clear
+ b.authors.clear()
+ # test setattr
+ b.authors.set([p])
+ # test M2M collection
+ b.delete()
+
+ def test_foreignkey_collection(self):
+ person = Person.objects.create(name="Bob")
+ Pet.objects.create(owner=person, name="Wart")
+ # test related FK collection
+ person.delete()
+
+
+class SyncOnlyDefaultDatabaseRouter:
+ def allow_migrate(self, db, app_label, **hints):
+ return db == DEFAULT_DB_ALIAS
+
+
+class MigrateTestCase(TestCase):
+ # Limit memory usage when calling 'migrate'.
+ available_apps = [
+ "multiple_database",
+ "django.contrib.auth",
+ "django.contrib.contenttypes",
+ ]
+ databases = {"default", "other"}
+
+ def test_migrate_to_other_database(self):
+ """Regression test for #16039: migrate with --database option."""
+ cts = ContentType.objects.using("other").filter(app_label="multiple_database")
+
+ count = cts.count()
+ self.assertGreater(count, 0)
+
+ cts.delete()
+ management.call_command(
+ "migrate", verbosity=0, interactive=False, database="other"
+ )
+ self.assertEqual(cts.count(), count)
+
+ def test_migrate_to_other_database_with_router(self):
+ """Regression test for #16039: migrate with --database option."""
+ cts = ContentType.objects.using("other").filter(app_label="multiple_database")
+
+ cts.delete()
+ with override_settings(DATABASE_ROUTERS=[SyncOnlyDefaultDatabaseRouter()]):
+ management.call_command(
+ "migrate", verbosity=0, interactive=False, database="other"
+ )
+
+ self.assertEqual(cts.count(), 0)
+
+
+class RouterUsed(Exception):
+ WRITE = "write"
+
+ def __init__(self, mode, model, hints):
+ self.mode = mode
+ self.model = model
+ self.hints = hints
+
+
+class RouteForWriteTestCase(TestCase):
+ databases = {"default", "other"}
+
+ class WriteCheckRouter:
+ def db_for_write(self, model, **hints):
+ raise RouterUsed(mode=RouterUsed.WRITE, model=model, hints=hints)
+
+ def override_router(self):
+ return override_settings(
+ DATABASE_ROUTERS=[RouteForWriteTestCase.WriteCheckRouter()]
+ )
+
+ def test_fk_delete(self):
+ owner = Person.objects.create(name="Someone")
+ pet = Pet.objects.create(name="fido", owner=owner)
+ with self.assertRaises(RouterUsed) as cm:
+ with self.override_router():
+ pet.owner.delete()
+ e = cm.exception
+ self.assertEqual(e.mode, RouterUsed.WRITE)
+ self.assertEqual(e.model, Person)
+ self.assertEqual(e.hints, {"instance": owner})
+
+ def test_reverse_fk_delete(self):
+ owner = Person.objects.create(name="Someone")
+ to_del_qs = owner.pet_set.all()
+ with self.assertRaises(RouterUsed) as cm:
+ with self.override_router():
+ to_del_qs.delete()
+ e = cm.exception
+ self.assertEqual(e.mode, RouterUsed.WRITE)
+ self.assertEqual(e.model, Pet)
+ self.assertEqual(e.hints, {"instance": owner})
+
+ def test_reverse_fk_get_or_create(self):
+ owner = Person.objects.create(name="Someone")
+ with self.assertRaises(RouterUsed) as cm:
+ with self.override_router():
+ owner.pet_set.get_or_create(name="fido")
+ e = cm.exception
+ self.assertEqual(e.mode, RouterUsed.WRITE)
+ self.assertEqual(e.model, Pet)
+ self.assertEqual(e.hints, {"instance": owner})
+
+ def test_reverse_fk_update(self):
+ owner = Person.objects.create(name="Someone")
+ Pet.objects.create(name="fido", owner=owner)
+ with self.assertRaises(RouterUsed) as cm:
+ with self.override_router():
+ owner.pet_set.update(name="max")
+ e = cm.exception
+ self.assertEqual(e.mode, RouterUsed.WRITE)
+ self.assertEqual(e.model, Pet)
+ self.assertEqual(e.hints, {"instance": owner})
+
+ def test_m2m_add(self):
+ auth = Person.objects.create(name="Someone")
+ book = Book.objects.create(
+ title="Pro Django", published=datetime.date(2008, 12, 16)
+ )
+ with self.assertRaises(RouterUsed) as cm:
+ with self.override_router():
+ book.authors.add(auth)
+ e = cm.exception
+ self.assertEqual(e.mode, RouterUsed.WRITE)
+ self.assertEqual(e.model, Book.authors.through)
+ self.assertEqual(e.hints, {"instance": book})
+
+ def test_m2m_clear(self):
+ auth = Person.objects.create(name="Someone")
+ book = Book.objects.create(
+ title="Pro Django", published=datetime.date(2008, 12, 16)
+ )
+ book.authors.add(auth)
+ with self.assertRaises(RouterUsed) as cm:
+ with self.override_router():
+ book.authors.clear()
+ e = cm.exception
+ self.assertEqual(e.mode, RouterUsed.WRITE)
+ self.assertEqual(e.model, Book.authors.through)
+ self.assertEqual(e.hints, {"instance": book})
+
+ def test_m2m_delete(self):
+ auth = Person.objects.create(name="Someone")
+ book = Book.objects.create(
+ title="Pro Django", published=datetime.date(2008, 12, 16)
+ )
+ book.authors.add(auth)
+ with self.assertRaises(RouterUsed) as cm:
+ with self.override_router():
+ book.authors.all().delete()
+ e = cm.exception
+ self.assertEqual(e.mode, RouterUsed.WRITE)
+ self.assertEqual(e.model, Person)
+ self.assertEqual(e.hints, {"instance": book})
+
+ def test_m2m_get_or_create(self):
+ Person.objects.create(name="Someone")
+ book = Book.objects.create(
+ title="Pro Django", published=datetime.date(2008, 12, 16)
+ )
+ with self.assertRaises(RouterUsed) as cm:
+ with self.override_router():
+ book.authors.get_or_create(name="Someone else")
+ e = cm.exception
+ self.assertEqual(e.mode, RouterUsed.WRITE)
+ self.assertEqual(e.model, Book)
+ self.assertEqual(e.hints, {"instance": book})
+
+ def test_m2m_remove(self):
+ auth = Person.objects.create(name="Someone")
+ book = Book.objects.create(
+ title="Pro Django", published=datetime.date(2008, 12, 16)
+ )
+ book.authors.add(auth)
+ with self.assertRaises(RouterUsed) as cm:
+ with self.override_router():
+ book.authors.remove(auth)
+ e = cm.exception
+ self.assertEqual(e.mode, RouterUsed.WRITE)
+ self.assertEqual(e.model, Book.authors.through)
+ self.assertEqual(e.hints, {"instance": book})
+
+ def test_m2m_update(self):
+ auth = Person.objects.create(name="Someone")
+ book = Book.objects.create(
+ title="Pro Django", published=datetime.date(2008, 12, 16)
+ )
+ book.authors.add(auth)
+ with self.assertRaises(RouterUsed) as cm:
+ with self.override_router():
+ book.authors.update(name="Different")
+ e = cm.exception
+ self.assertEqual(e.mode, RouterUsed.WRITE)
+ self.assertEqual(e.model, Person)
+ self.assertEqual(e.hints, {"instance": book})
+
+ def test_reverse_m2m_add(self):
+ auth = Person.objects.create(name="Someone")
+ book = Book.objects.create(
+ title="Pro Django", published=datetime.date(2008, 12, 16)
+ )
+ with self.assertRaises(RouterUsed) as cm:
+ with self.override_router():
+ auth.book_set.add(book)
+ e = cm.exception
+ self.assertEqual(e.mode, RouterUsed.WRITE)
+ self.assertEqual(e.model, Book.authors.through)
+ self.assertEqual(e.hints, {"instance": auth})
+
+ def test_reverse_m2m_clear(self):
+ auth = Person.objects.create(name="Someone")
+ book = Book.objects.create(
+ title="Pro Django", published=datetime.date(2008, 12, 16)
+ )
+ book.authors.add(auth)
+ with self.assertRaises(RouterUsed) as cm:
+ with self.override_router():
+ auth.book_set.clear()
+ e = cm.exception
+ self.assertEqual(e.mode, RouterUsed.WRITE)
+ self.assertEqual(e.model, Book.authors.through)
+ self.assertEqual(e.hints, {"instance": auth})
+
+ def test_reverse_m2m_delete(self):
+ auth = Person.objects.create(name="Someone")
+ book = Book.objects.create(
+ title="Pro Django", published=datetime.date(2008, 12, 16)
+ )
+ book.authors.add(auth)
+ with self.assertRaises(RouterUsed) as cm:
+ with self.override_router():
+ auth.book_set.all().delete()
+ e = cm.exception
+ self.assertEqual(e.mode, RouterUsed.WRITE)
+ self.assertEqual(e.model, Book)
+ self.assertEqual(e.hints, {"instance": auth})
+
+ def test_reverse_m2m_get_or_create(self):
+ auth = Person.objects.create(name="Someone")
+ Book.objects.create(title="Pro Django", published=datetime.date(2008, 12, 16))
+ with self.assertRaises(RouterUsed) as cm:
+ with self.override_router():
+ auth.book_set.get_or_create(
+ title="New Book", published=datetime.datetime.now()
+ )
+ e = cm.exception
+ self.assertEqual(e.mode, RouterUsed.WRITE)
+ self.assertEqual(e.model, Person)
+ self.assertEqual(e.hints, {"instance": auth})
+
+ def test_reverse_m2m_remove(self):
+ auth = Person.objects.create(name="Someone")
+ book = Book.objects.create(
+ title="Pro Django", published=datetime.date(2008, 12, 16)
+ )
+ book.authors.add(auth)
+ with self.assertRaises(RouterUsed) as cm:
+ with self.override_router():
+ auth.book_set.remove(book)
+ e = cm.exception
+ self.assertEqual(e.mode, RouterUsed.WRITE)
+ self.assertEqual(e.model, Book.authors.through)
+ self.assertEqual(e.hints, {"instance": auth})
+
+ def test_reverse_m2m_update(self):
+ auth = Person.objects.create(name="Someone")
+ book = Book.objects.create(
+ title="Pro Django", published=datetime.date(2008, 12, 16)
+ )
+ book.authors.add(auth)
+ with self.assertRaises(RouterUsed) as cm:
+ with self.override_router():
+ auth.book_set.update(title="Different")
+ e = cm.exception
+ self.assertEqual(e.mode, RouterUsed.WRITE)
+ self.assertEqual(e.model, Book)
+ self.assertEqual(e.hints, {"instance": auth})
+
+
+class NoRelationRouter:
+ """Disallow all relations."""
+
+ def allow_relation(self, obj1, obj2, **hints):
+ return False
+
+
+@override_settings(DATABASE_ROUTERS=[NoRelationRouter()])
+class RelationAssignmentTests(SimpleTestCase):
+ """allow_relation() is called with unsaved model instances."""
+
+ databases = {"default", "other"}
+ router_prevents_msg = "the current database router prevents this relation"
+
+ def test_foreign_key_relation(self):
+ person = Person(name="Someone")
+ pet = Pet()
+ with self.assertRaisesMessage(ValueError, self.router_prevents_msg):
+ pet.owner = person
+
+ def test_reverse_one_to_one_relation(self):
+ user = User(username="Someone", password="fake_hash")
+ profile = UserProfile()
+ with self.assertRaisesMessage(ValueError, self.router_prevents_msg):
+ user.userprofile = profile
diff --git a/testbed/django__django/tests/nested_foreign_keys/models.py b/testbed/django__django/tests/nested_foreign_keys/models.py
new file mode 100644
index 0000000000000000000000000000000000000000..5805de5d521dcb1dcbad08741e02b2a1ab8a343e
--- /dev/null
+++ b/testbed/django__django/tests/nested_foreign_keys/models.py
@@ -0,0 +1,30 @@
+from django.db import models
+
+
+class Person(models.Model):
+ name = models.CharField(max_length=200)
+
+
+class Movie(models.Model):
+ title = models.CharField(max_length=200)
+ director = models.ForeignKey(Person, models.CASCADE)
+
+
+class Event(models.Model):
+ pass
+
+
+class Screening(Event):
+ movie = models.ForeignKey(Movie, models.CASCADE)
+
+
+class ScreeningNullFK(Event):
+ movie = models.ForeignKey(Movie, models.SET_NULL, null=True)
+
+
+class Package(models.Model):
+ screening = models.ForeignKey(Screening, models.SET_NULL, null=True)
+
+
+class PackageNullFK(models.Model):
+ screening = models.ForeignKey(ScreeningNullFK, models.SET_NULL, null=True)
diff --git a/testbed/django__django/tests/null_fk/models.py b/testbed/django__django/tests/null_fk/models.py
new file mode 100644
index 0000000000000000000000000000000000000000..13a425f646bb599c9be899af4199fe74a48b1b00
--- /dev/null
+++ b/testbed/django__django/tests/null_fk/models.py
@@ -0,0 +1,52 @@
+"""
+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)
diff --git a/testbed/django__django/tests/null_fk/tests.py b/testbed/django__django/tests/null_fk/tests.py
new file mode 100644
index 0000000000000000000000000000000000000000..9bf5f93f6c47f7a153495985bc07f9af7cb046b0
--- /dev/null
+++ b/testbed/django__django/tests/null_fk/tests.py
@@ -0,0 +1,67 @@
+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", ""),
+ (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", ""),
+ (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))
diff --git a/testbed/django__django/tests/null_fk_ordering/__init__.py b/testbed/django__django/tests/null_fk_ordering/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testbed/django__django/tests/null_fk_ordering/models.py b/testbed/django__django/tests/null_fk_ordering/models.py
new file mode 100644
index 0000000000000000000000000000000000000000..adfdbf3bea4f02c1a7f7fe9cb43091f3e63710eb
--- /dev/null
+++ b/testbed/django__django/tests/null_fk_ordering/models.py
@@ -0,0 +1,44 @@
+"""
+Regression tests for proper working of ForeignKey(null=True). Tests these bugs:
+
+ * #7512: including a nullable foreign key reference in Meta ordering has
+unexpected results
+
+"""
+from django.db import models
+
+
+# The first two models represent a very simple null FK ordering case.
+class Author(models.Model):
+ name = models.CharField(max_length=150)
+
+
+class Article(models.Model):
+ title = models.CharField(max_length=150)
+ author = models.ForeignKey(Author, models.SET_NULL, null=True)
+
+ class Meta:
+ ordering = ["author__name"]
+
+
+# These following 4 models represent a far more complex ordering case.
+class SystemInfo(models.Model):
+ 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)
+
+
+class Comment(models.Model):
+ post = models.ForeignKey(Post, models.SET_NULL, null=True)
+ comment_text = models.CharField(max_length=250)
+
+ class Meta:
+ ordering = ["post__forum__system_info__system_name", "comment_text"]
diff --git a/testbed/django__django/tests/null_fk_ordering/tests.py b/testbed/django__django/tests/null_fk_ordering/tests.py
new file mode 100644
index 0000000000000000000000000000000000000000..506c8b4086852e0c26ff156d47696fc366a4170f
--- /dev/null
+++ b/testbed/django__django/tests/null_fk_ordering/tests.py
@@ -0,0 +1,43 @@
+from django.test import TestCase
+
+from .models import Article, Author, Comment, Forum, Post, SystemInfo
+
+
+class NullFkOrderingTests(TestCase):
+ def test_ordering_across_null_fk(self):
+ """
+ Regression test for #7512
+
+ ordering across nullable Foreign Keys shouldn't exclude results
+ """
+ author_1 = Author.objects.create(name="Tom Jones")
+ author_2 = Author.objects.create(name="Bob Smith")
+ Article.objects.create(title="No author on this article")
+ Article.objects.create(
+ author=author_1, title="This article written by Tom Jones"
+ )
+ Article.objects.create(
+ author=author_2, title="This article written by Bob Smith"
+ )
+
+ # We can't compare results directly (since different databases sort NULLs to
+ # different ends of the ordering), but we can check that all results are
+ # returned.
+ self.assertEqual(len(list(Article.objects.all())), 3)
+
+ s = SystemInfo.objects.create(system_name="System Info")
+ f = Forum.objects.create(system_info=s, forum_name="First forum")
+ p = Post.objects.create(forum=f, title="First Post")
+ Comment.objects.create(post=p, comment_text="My first comment")
+ Comment.objects.create(comment_text="My second comment")
+ s2 = SystemInfo.objects.create(system_name="More System Info")
+ f2 = Forum.objects.create(system_info=s2, forum_name="Second forum")
+ p2 = Post.objects.create(forum=f2, title="Second Post")
+ Comment.objects.create(comment_text="Another first comment")
+ Comment.objects.create(post=p2, comment_text="Another second comment")
+
+ # We have to test this carefully. Some databases sort NULL values before
+ # everything else, some sort them afterward. So we extract the ordered list
+ # and check the length. Before the fix, this list was too short (some values
+ # were omitted).
+ self.assertEqual(len(list(Comment.objects.all())), 4)
diff --git a/testbed/django__django/tests/null_queries/models.py b/testbed/django__django/tests/null_queries/models.py
new file mode 100644
index 0000000000000000000000000000000000000000..2ed7fef2cce2a0726bf8c62e95bbd8d010529cdd
--- /dev/null
+++ b/testbed/django__django/tests/null_queries/models.py
@@ -0,0 +1,27 @@
+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)
diff --git a/testbed/django__django/tests/one_to_one/models.py b/testbed/django__django/tests/one_to_one/models.py
new file mode 100644
index 0000000000000000000000000000000000000000..ca459e9edfececb16ee879a991cb13480639a266
--- /dev/null
+++ b/testbed/django__django/tests/one_to_one/models.py
@@ -0,0 +1,111 @@
+"""
+One-to-one relationships
+
+To define a one-to-one relationship, use ``OneToOneField()``.
+
+In this example, a ``Place`` optionally can be a ``Restaurant``.
+"""
+from django.db import models
+
+
+class Place(models.Model):
+ name = models.CharField(max_length=50)
+ address = models.CharField(max_length=80)
+
+ def __str__(self):
+ return "%s the place" % self.name
+
+
+class Restaurant(models.Model):
+ place = models.OneToOneField(Place, models.CASCADE, primary_key=True)
+ serves_hot_dogs = models.BooleanField(default=False)
+ serves_pizza = models.BooleanField(default=False)
+
+ def __str__(self):
+ return "%s the restaurant" % self.place.name
+
+
+class Bar(models.Model):
+ place = models.OneToOneField(Place, models.CASCADE)
+ serves_cocktails = models.BooleanField(default=True)
+
+
+class UndergroundBar(models.Model):
+ place = models.OneToOneField(Place, models.SET_NULL, null=True)
+ serves_cocktails = models.BooleanField(default=True)
+
+
+class Waiter(models.Model):
+ restaurant = models.ForeignKey(Restaurant, models.CASCADE)
+ name = models.CharField(max_length=50)
+
+ def __str__(self):
+ return "%s the waiter at %s" % (self.name, self.restaurant)
+
+
+class Favorites(models.Model):
+ name = models.CharField(max_length=50)
+ restaurants = models.ManyToManyField(Restaurant)
+
+
+class ManualPrimaryKey(models.Model):
+ primary_key = models.CharField(max_length=10, primary_key=True)
+ name = models.CharField(max_length=50)
+
+
+class RelatedModel(models.Model):
+ link = models.OneToOneField(ManualPrimaryKey, models.CASCADE)
+ name = models.CharField(max_length=50)
+
+
+class MultiModel(models.Model):
+ link1 = models.OneToOneField(Place, models.CASCADE)
+ link2 = models.OneToOneField(ManualPrimaryKey, models.CASCADE)
+ name = models.CharField(max_length=50)
+
+ def __str__(self):
+ return "Multimodel %s" % self.name
+
+
+class Target(models.Model):
+ name = models.CharField(max_length=50, unique=True)
+
+
+class Pointer(models.Model):
+ other = models.OneToOneField(Target, models.CASCADE, primary_key=True)
+
+
+class Pointer2(models.Model):
+ other = models.OneToOneField(Target, models.CASCADE, related_name="second_pointer")
+
+
+class HiddenPointer(models.Model):
+ target = models.OneToOneField(Target, models.CASCADE, related_name="hidden+")
+
+
+class ToFieldPointer(models.Model):
+ target = models.OneToOneField(
+ Target, models.CASCADE, to_field="name", primary_key=True
+ )
+
+
+# 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 DirectorManager(models.Manager):
+ def get_queryset(self):
+ return super().get_queryset().filter(is_temp=False)
+
+
+class Director(models.Model):
+ is_temp = models.BooleanField(default=False)
+ school = models.OneToOneField(School, models.CASCADE)
+ objects = DirectorManager()
diff --git a/testbed/django__django/tests/one_to_one/tests.py b/testbed/django__django/tests/one_to_one/tests.py
new file mode 100644
index 0000000000000000000000000000000000000000..3c92445af6a82a6d892dc39220bf35f37ae7b917
--- /dev/null
+++ b/testbed/django__django/tests/one_to_one/tests.py
@@ -0,0 +1,585 @@
+from django.db import IntegrityError, connection, transaction
+from django.test import TestCase
+
+from .models import (
+ Bar,
+ Director,
+ Favorites,
+ HiddenPointer,
+ ManualPrimaryKey,
+ MultiModel,
+ Place,
+ Pointer,
+ RelatedModel,
+ Restaurant,
+ School,
+ Target,
+ ToFieldPointer,
+ UndergroundBar,
+ Waiter,
+)
+
+
+class OneToOneTests(TestCase):
+ @classmethod
+ def setUpTestData(cls):
+ cls.p1 = Place.objects.create(name="Demon Dogs", address="944 W. Fullerton")
+ cls.p2 = Place.objects.create(name="Ace Hardware", address="1013 N. Ashland")
+ cls.r1 = Restaurant.objects.create(
+ place=cls.p1, serves_hot_dogs=True, serves_pizza=False
+ )
+ cls.b1 = Bar.objects.create(place=cls.p1, serves_cocktails=False)
+
+ def test_getter(self):
+ # A Restaurant can access its place.
+ self.assertEqual(repr(self.r1.place), "")
+ # A Place can access its restaurant, if available.
+ self.assertEqual(
+ repr(self.p1.restaurant), ""
+ )
+ # p2 doesn't have an associated restaurant.
+ with self.assertRaisesMessage(
+ Restaurant.DoesNotExist, "Place has no restaurant"
+ ):
+ self.p2.restaurant
+ # 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(self.p2, "restaurant"))
+
+ def test_setter(self):
+ # Set the place using assignment notation. Because place is the primary
+ # key on Restaurant, the save will create a new restaurant
+ self.r1.place = self.p2
+ self.r1.save()
+ self.assertEqual(
+ repr(self.p2.restaurant), ""
+ )
+ self.assertEqual(repr(self.r1.place), "")
+ self.assertEqual(self.p2.pk, self.r1.pk)
+ # Set the place back again, using assignment in the reverse direction.
+ self.p1.restaurant = self.r1
+ self.assertEqual(
+ repr(self.p1.restaurant), ""
+ )
+ r = Restaurant.objects.get(pk=self.p1.id)
+ self.assertEqual(repr(r.place), "")
+
+ def test_manager_all(self):
+ # Restaurant.objects.all() just returns the Restaurants, not the Places.
+ self.assertSequenceEqual(Restaurant.objects.all(), [self.r1])
+ # Place.objects.all() returns all Places, regardless of whether they
+ # have Restaurants.
+ self.assertSequenceEqual(Place.objects.order_by("name"), [self.p2, self.p1])
+
+ def test_manager_get(self):
+ def assert_get_restaurant(**params):
+ self.assertEqual(
+ repr(Restaurant.objects.get(**params)),
+ "",
+ )
+
+ assert_get_restaurant(place__id__exact=self.p1.pk)
+ assert_get_restaurant(place__id=self.p1.pk)
+ assert_get_restaurant(place__exact=self.p1.pk)
+ assert_get_restaurant(place__exact=self.p1)
+ assert_get_restaurant(place=self.p1.pk)
+ assert_get_restaurant(place=self.p1)
+ assert_get_restaurant(pk=self.p1.pk)
+ assert_get_restaurant(place__pk__exact=self.p1.pk)
+ assert_get_restaurant(place__pk=self.p1.pk)
+ assert_get_restaurant(place__name__startswith="Demon")
+
+ def assert_get_place(**params):
+ self.assertEqual(
+ repr(Place.objects.get(**params)), ""
+ )
+
+ assert_get_place(restaurant__place__exact=self.p1.pk)
+ assert_get_place(restaurant__place__exact=self.p1)
+ assert_get_place(restaurant__place__pk=self.p1.pk)
+ assert_get_place(restaurant__exact=self.p1.pk)
+ assert_get_place(restaurant__exact=self.r1)
+ assert_get_place(restaurant__pk=self.p1.pk)
+ assert_get_place(restaurant=self.p1.pk)
+ assert_get_place(restaurant=self.r1)
+ assert_get_place(id__exact=self.p1.pk)
+ assert_get_place(pk=self.p1.pk)
+
+ def test_foreign_key(self):
+ # Add a Waiter to the Restaurant.
+ w = self.r1.waiter_set.create(name="Joe")
+ self.assertEqual(
+ repr(w), ""
+ )
+
+ # Query the waiters
+ def assert_filter_waiters(**params):
+ self.assertSequenceEqual(Waiter.objects.filter(**params), [w])
+
+ assert_filter_waiters(restaurant__place__exact=self.p1.pk)
+ assert_filter_waiters(restaurant__place__exact=self.p1)
+ assert_filter_waiters(restaurant__place__pk=self.p1.pk)
+ assert_filter_waiters(restaurant__exact=self.r1.pk)
+ assert_filter_waiters(restaurant__exact=self.r1)
+ assert_filter_waiters(restaurant__pk=self.r1.pk)
+ assert_filter_waiters(restaurant=self.r1.pk)
+ assert_filter_waiters(restaurant=self.r1)
+ assert_filter_waiters(id__exact=w.pk)
+ assert_filter_waiters(pk=w.pk)
+ # Delete the restaurant; the waiter should also be removed
+ r = Restaurant.objects.get(pk=self.r1.pk)
+ r.delete()
+ self.assertEqual(Waiter.objects.count(), 0)
+
+ def test_multiple_o2o(self):
+ # One-to-one fields still work if you create your own primary key
+ o1 = ManualPrimaryKey(primary_key="abc123", name="primary")
+ o1.save()
+ o2 = RelatedModel(link=o1, name="secondary")
+ o2.save()
+
+ # You can have multiple one-to-one fields on a model, too.
+ x1 = MultiModel(link1=self.p1, link2=o1, name="x1")
+ x1.save()
+ self.assertEqual(repr(o1.multimodel), "")
+ # This will fail because each one-to-one field must be unique (and
+ # link2=o1 was used for x1, above).
+ mm = MultiModel(link1=self.p2, link2=o1, name="x1")
+ with self.assertRaises(IntegrityError):
+ with transaction.atomic():
+ mm.save()
+
+ def test_unsaved_object(self):
+ """
+ #10811 -- Assigning an unsaved object to a OneToOneField
+ should raise an exception.
+ """
+ place = Place(name="User", address="London")
+ with self.assertRaises(Restaurant.DoesNotExist):
+ place.restaurant
+ msg = (
+ "save() prohibited to prevent data loss due to unsaved related object "
+ "'place'."
+ )
+ with self.assertRaisesMessage(ValueError, msg):
+ Restaurant.objects.create(
+ place=place, serves_hot_dogs=True, serves_pizza=False
+ )
+ # place should not cache restaurant
+ with self.assertRaises(Restaurant.DoesNotExist):
+ place.restaurant
+
+ def test_reverse_relationship_cache_cascade(self):
+ """
+ Regression test for #9023: accessing the reverse relationship shouldn't
+ result in a cascading delete().
+ """
+ bar = UndergroundBar.objects.create(place=self.p1, serves_cocktails=False)
+
+ # The bug in #9023: if you access the one-to-one relation *before*
+ # setting to None and deleting, the cascade happens anyway.
+ self.p1.undergroundbar
+ bar.place.name = "foo"
+ bar.place = None
+ bar.save()
+ self.p1.delete()
+
+ self.assertEqual(Place.objects.count(), 1)
+ self.assertEqual(UndergroundBar.objects.count(), 1)
+
+ def test_create_models_m2m(self):
+ """
+ Models are created via the m2m relation if the remote model has a
+ OneToOneField (#1064, #1506).
+ """
+ f = Favorites(name="Fred")
+ f.save()
+ f.restaurants.set([self.r1])
+ self.assertSequenceEqual(f.restaurants.all(), [self.r1])
+
+ def test_reverse_object_cache(self):
+ """
+ The name of the cache for the reverse object is correct (#7173).
+ """
+ self.assertEqual(self.p1.restaurant, self.r1)
+ self.assertEqual(self.p1.bar, self.b1)
+
+ def test_assign_none_reverse_relation(self):
+ p = Place.objects.get(name="Demon Dogs")
+ # Assigning None succeeds if field is null=True.
+ ug_bar = UndergroundBar.objects.create(place=p, serves_cocktails=False)
+ p.undergroundbar = None
+ self.assertIsNone(ug_bar.place)
+ ug_bar.save()
+ ug_bar.refresh_from_db()
+ self.assertIsNone(ug_bar.place)
+
+ def test_assign_none_null_reverse_relation(self):
+ p = Place.objects.get(name="Demon Dogs")
+ # Assigning None doesn't throw AttributeError if there isn't a related
+ # UndergroundBar.
+ p.undergroundbar = None
+
+ def test_assign_none_to_null_cached_reverse_relation(self):
+ p = Place.objects.get(name="Demon Dogs")
+ # Prime the relation's cache with a value of None.
+ with self.assertRaises(Place.undergroundbar.RelatedObjectDoesNotExist):
+ getattr(p, "undergroundbar")
+ # Assigning None works if there isn't a related UndergroundBar and the
+ # reverse cache has a value of None.
+ p.undergroundbar = None
+
+ def test_assign_o2o_id_value(self):
+ b = UndergroundBar.objects.create(place=self.p1)
+ b.place_id = self.p2.pk
+ b.save()
+ self.assertEqual(b.place_id, self.p2.pk)
+ self.assertFalse(UndergroundBar.place.is_cached(b))
+ self.assertEqual(b.place, self.p2)
+ self.assertTrue(UndergroundBar.place.is_cached(b))
+ # Reassigning the same value doesn't clear a cached instance.
+ b.place_id = self.p2.pk
+ self.assertTrue(UndergroundBar.place.is_cached(b))
+
+ def test_assign_o2o_id_none(self):
+ b = UndergroundBar.objects.create(place=self.p1)
+ b.place_id = None
+ b.save()
+ self.assertIsNone(b.place_id)
+ self.assertFalse(UndergroundBar.place.is_cached(b))
+ self.assertIsNone(b.place)
+ self.assertTrue(UndergroundBar.place.is_cached(b))
+
+ def test_related_object_cache(self):
+ """Regression test for #6886 (the related-object cache)"""
+
+ # Look up the objects again so that we get "fresh" objects
+ p = Place.objects.get(name="Demon Dogs")
+ r = p.restaurant
+
+ # Accessing the related object again returns the exactly same object
+ self.assertIs(p.restaurant, r)
+
+ # But if we kill the cache, we get a new object
+ del p._state.fields_cache["restaurant"]
+ self.assertIsNot(p.restaurant, r)
+
+ # Reassigning the Restaurant object results in an immediate cache update
+ # We can't use a new Restaurant because that'll violate one-to-one, but
+ # with a new *instance* the is test below will fail if #6886 regresses.
+ r2 = Restaurant.objects.get(pk=r.pk)
+ p.restaurant = r2
+ self.assertIs(p.restaurant, r2)
+
+ # Assigning None succeeds if field is null=True.
+ ug_bar = UndergroundBar.objects.create(place=p, serves_cocktails=False)
+ ug_bar.place = None
+ self.assertIsNone(ug_bar.place)
+
+ # Assigning None will not fail: Place.restaurant is null=False
+ setattr(p, "restaurant", None)
+
+ # You also can't assign an object of the wrong type here
+ msg = (
+ 'Cannot assign "": '
+ '"Place.restaurant" must be a "Restaurant" instance.'
+ )
+ with self.assertRaisesMessage(ValueError, msg):
+ setattr(p, "restaurant", p)
+
+ # Creation using keyword argument should cache the related object.
+ p = Place.objects.get(name="Demon Dogs")
+ r = Restaurant(place=p)
+ self.assertIs(r.place, p)
+
+ # Creation using keyword argument and unsaved related instance (#8070).
+ p = Place()
+ r = Restaurant(place=p)
+ self.assertIs(r.place, p)
+
+ # Creation using attname keyword argument and an id will cause the related
+ # object to be fetched.
+ p = Place.objects.get(name="Demon Dogs")
+ r = Restaurant(place_id=p.id)
+ self.assertIsNot(r.place, p)
+ self.assertEqual(r.place, p)
+
+ def test_filter_one_to_one_relations(self):
+ """
+ Regression test for #9968
+
+ filtering reverse one-to-one relations with primary_key=True was
+ misbehaving. We test both (primary_key=True & False) cases here to
+ prevent any reappearance of the problem.
+ """
+ target = Target.objects.create()
+ self.assertSequenceEqual(Target.objects.filter(pointer=None), [target])
+ self.assertSequenceEqual(Target.objects.exclude(pointer=None), [])
+ self.assertSequenceEqual(Target.objects.filter(second_pointer=None), [target])
+ self.assertSequenceEqual(Target.objects.exclude(second_pointer=None), [])
+
+ def test_o2o_primary_key_delete(self):
+ t = Target.objects.create(name="name")
+ Pointer.objects.create(other=t)
+ num_deleted, objs = Pointer.objects.filter(other__name="name").delete()
+ self.assertEqual(num_deleted, 1)
+ self.assertEqual(objs, {"one_to_one.Pointer": 1})
+
+ def test_save_nullable_o2o_after_parent(self):
+ place = Place(name="Rose tattoo")
+ bar = UndergroundBar(place=place)
+ place.save()
+ bar.save()
+ bar.refresh_from_db()
+ self.assertEqual(bar.place, place)
+
+ def test_reverse_object_does_not_exist_cache(self):
+ """
+ Regression for #13839 and #17439.
+
+ DoesNotExist on a reverse one-to-one relation is cached.
+ """
+ p = Place(name="Zombie Cats", address="Not sure")
+ p.save()
+ with self.assertNumQueries(1):
+ with self.assertRaises(Restaurant.DoesNotExist):
+ p.restaurant
+ with self.assertNumQueries(0):
+ with self.assertRaises(Restaurant.DoesNotExist):
+ p.restaurant
+
+ def test_reverse_object_cached_when_related_is_accessed(self):
+ """
+ Regression for #13839 and #17439.
+
+ The target of a one-to-one relation is cached
+ when the origin is accessed through the reverse relation.
+ """
+ # Use a fresh object without caches
+ r = Restaurant.objects.get(pk=self.r1.pk)
+ p = r.place
+ with self.assertNumQueries(0):
+ self.assertEqual(p.restaurant, r)
+
+ def test_related_object_cached_when_reverse_is_accessed(self):
+ """
+ Regression for #13839 and #17439.
+
+ The origin of a one-to-one relation is cached
+ when the target is accessed through the reverse relation.
+ """
+ # Use a fresh object without caches
+ p = Place.objects.get(pk=self.p1.pk)
+ r = p.restaurant
+ with self.assertNumQueries(0):
+ self.assertEqual(r.place, p)
+
+ def test_reverse_object_cached_when_related_is_set(self):
+ """
+ Regression for #13839 and #17439.
+
+ The target of a one-to-one relation is always cached.
+ """
+ p = Place(name="Zombie Cats", address="Not sure")
+ p.save()
+ self.r1.place = p
+ self.r1.save()
+ with self.assertNumQueries(0):
+ self.assertEqual(p.restaurant, self.r1)
+
+ def test_reverse_object_cached_when_related_is_unset(self):
+ """
+ Regression for #13839 and #17439.
+
+ The target of a one-to-one relation is always cached.
+ """
+ b = UndergroundBar(place=self.p1, serves_cocktails=True)
+ b.save()
+ with self.assertNumQueries(0):
+ self.assertEqual(self.p1.undergroundbar, b)
+ b.place = None
+ b.save()
+ with self.assertNumQueries(0):
+ with self.assertRaises(UndergroundBar.DoesNotExist):
+ self.p1.undergroundbar
+
+ def test_get_reverse_on_unsaved_object(self):
+ """
+ Regression for #18153 and #19089.
+
+ Accessing the reverse relation on an unsaved object
+ always raises an exception.
+ """
+ p = Place()
+
+ # When there's no instance of the origin of the one-to-one
+ with self.assertNumQueries(0):
+ with self.assertRaises(UndergroundBar.DoesNotExist):
+ p.undergroundbar
+
+ UndergroundBar.objects.create()
+
+ # When there's one instance of the origin
+ # (p.undergroundbar used to return that instance)
+ with self.assertNumQueries(0):
+ with self.assertRaises(UndergroundBar.DoesNotExist):
+ p.undergroundbar
+
+ # Several instances of the origin are only possible if database allows
+ # inserting multiple NULL rows for a unique constraint
+ if connection.features.supports_nullable_unique_constraints:
+ UndergroundBar.objects.create()
+
+ # When there are several instances of the origin
+ with self.assertNumQueries(0):
+ with self.assertRaises(UndergroundBar.DoesNotExist):
+ p.undergroundbar
+
+ def test_set_reverse_on_unsaved_object(self):
+ """
+ Writing to the reverse relation on an unsaved object
+ is impossible too.
+ """
+ p = Place()
+ b = UndergroundBar.objects.create()
+
+ # Assigning a reverse relation on an unsaved object is allowed.
+ p.undergroundbar = b
+
+ # However saving the object is not allowed.
+ msg = (
+ "save() prohibited to prevent data loss due to unsaved related object "
+ "'place'."
+ )
+ with self.assertNumQueries(0):
+ with self.assertRaisesMessage(ValueError, msg):
+ b.save()
+
+ def test_nullable_o2o_delete(self):
+ u = UndergroundBar.objects.create(place=self.p1)
+ u.place_id = None
+ u.save()
+ self.p1.delete()
+ self.assertTrue(UndergroundBar.objects.filter(pk=u.pk).exists())
+ self.assertIsNone(UndergroundBar.objects.get(pk=u.pk).place)
+
+ def test_hidden_accessor(self):
+ """
+ When a '+' ending related name is specified no reverse accessor should
+ be added to the related model.
+ """
+ self.assertFalse(
+ hasattr(
+ Target,
+ HiddenPointer._meta.get_field(
+ "target"
+ ).remote_field.get_accessor_name(),
+ )
+ )
+
+ def test_related_object(self):
+ public_school = School.objects.create(is_public=True)
+ public_director = Director.objects.create(school=public_school, is_temp=False)
+
+ private_school = School.objects.create(is_public=False)
+ private_director = Director.objects.create(school=private_school, is_temp=True)
+
+ # Only one school is available via all() due to the custom default manager.
+ self.assertSequenceEqual(School.objects.all(), [public_school])
+
+ # Only one director is available via all() due to the custom default manager.
+ self.assertSequenceEqual(Director.objects.all(), [public_director])
+
+ self.assertEqual(public_director.school, public_school)
+ self.assertEqual(public_school.director, public_director)
+
+ # Make sure the base manager is used so that the related objects
+ # is still accessible even if the default manager doesn't normally
+ # allow it.
+ self.assertEqual(private_director.school, private_school)
+
+ # Make sure the base manager is used so that an student can still access
+ # its related school even if the default manager doesn't normally
+ # allow it.
+ self.assertEqual(private_school.director, private_director)
+
+ School._meta.base_manager_name = "objects"
+ School._meta._expire_cache()
+ try:
+ private_director = Director._base_manager.get(pk=private_director.pk)
+ with self.assertRaises(School.DoesNotExist):
+ private_director.school
+ finally:
+ School._meta.base_manager_name = None
+ School._meta._expire_cache()
+
+ Director._meta.base_manager_name = "objects"
+ Director._meta._expire_cache()
+ try:
+ private_school = School._base_manager.get(pk=private_school.pk)
+ with self.assertRaises(Director.DoesNotExist):
+ private_school.director
+ finally:
+ Director._meta.base_manager_name = None
+ Director._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(Director(), "director"))
+ self.assertFalse(hasattr(School(), "school"))
+
+ def test_update_one_to_one_pk(self):
+ p1 = Place.objects.create()
+ p2 = Place.objects.create()
+ r1 = Restaurant.objects.create(place=p1)
+ r2 = Restaurant.objects.create(place=p2)
+ w = Waiter.objects.create(restaurant=r1)
+
+ Waiter.objects.update(restaurant=r2)
+ w.refresh_from_db()
+ self.assertEqual(w.restaurant, r2)
+
+ def test_rel_pk_subquery(self):
+ r = Restaurant.objects.first()
+ q1 = Restaurant.objects.filter(place_id=r.pk)
+ # Subquery using primary key and a query against the
+ # same model works correctly.
+ q2 = Restaurant.objects.filter(place_id__in=q1)
+ self.assertSequenceEqual(q2, [r])
+ # Subquery using 'pk__in' instead of 'place_id__in' work, too.
+ q2 = Restaurant.objects.filter(
+ pk__in=Restaurant.objects.filter(place__id=r.place.pk)
+ )
+ self.assertSequenceEqual(q2, [r])
+ q3 = Restaurant.objects.filter(place__in=Place.objects.all())
+ self.assertSequenceEqual(q3, [r])
+ q4 = Restaurant.objects.filter(place__in=Place.objects.filter(id=r.pk))
+ self.assertSequenceEqual(q4, [r])
+
+ def test_rel_pk_exact(self):
+ r = Restaurant.objects.first()
+ r2 = Restaurant.objects.filter(pk__exact=r).first()
+ self.assertEqual(r, r2)
+
+ def test_primary_key_to_field_filter(self):
+ target = Target.objects.create(name="foo")
+ pointer = ToFieldPointer.objects.create(target=target)
+ self.assertSequenceEqual(
+ ToFieldPointer.objects.filter(target=target), [pointer]
+ )
+ self.assertSequenceEqual(
+ ToFieldPointer.objects.filter(pk__exact=pointer), [pointer]
+ )
+
+ def test_cached_relation_invalidated_on_save(self):
+ """
+ Model.save() invalidates stale OneToOneField relations after a primary
+ key assignment.
+ """
+ self.assertEqual(self.b1.place, self.p1) # caches b1.place
+ self.b1.place_id = self.p2.pk
+ self.b1.save()
+ self.assertEqual(self.b1.place, self.p2)
diff --git a/testbed/django__django/tests/or_lookups/__init__.py b/testbed/django__django/tests/or_lookups/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testbed/django__django/tests/or_lookups/models.py b/testbed/django__django/tests/or_lookups/models.py
new file mode 100644
index 0000000000000000000000000000000000000000..76090da9f3957d73e9777a9e9bc1bb8801fccc77
--- /dev/null
+++ b/testbed/django__django/tests/or_lookups/models.py
@@ -0,0 +1,22 @@
+"""
+OR lookups
+
+To perform an OR lookup, or a lookup that combines ANDs and ORs, combine
+``QuerySet`` objects using ``&`` and ``|`` operators.
+
+Alternatively, use positional arguments, and pass one or more expressions of
+clauses using the variable ``django.db.models.Q``.
+"""
+
+from django.db import models
+
+
+class Article(models.Model):
+ headline = models.CharField(max_length=50)
+ pub_date = models.DateTimeField()
+
+ class Meta:
+ ordering = ("pub_date",)
+
+ def __str__(self):
+ return self.headline
diff --git a/testbed/django__django/tests/or_lookups/tests.py b/testbed/django__django/tests/or_lookups/tests.py
new file mode 100644
index 0000000000000000000000000000000000000000..bfcb32bea75ec0e5858b5349fea897bafe4db4ae
--- /dev/null
+++ b/testbed/django__django/tests/or_lookups/tests.py
@@ -0,0 +1,222 @@
+from datetime import datetime
+from operator import attrgetter
+
+from django.db.models import Q
+from django.test import TestCase
+
+from .models import Article
+
+
+class OrLookupsTests(TestCase):
+ @classmethod
+ def setUpTestData(cls):
+ cls.a1 = Article.objects.create(
+ headline="Hello", pub_date=datetime(2005, 11, 27)
+ ).pk
+ cls.a2 = Article.objects.create(
+ headline="Goodbye", pub_date=datetime(2005, 11, 28)
+ ).pk
+ cls.a3 = Article.objects.create(
+ headline="Hello and goodbye", pub_date=datetime(2005, 11, 29)
+ ).pk
+
+ def test_filter_or(self):
+ self.assertQuerySetEqual(
+ (
+ Article.objects.filter(headline__startswith="Hello")
+ | Article.objects.filter(headline__startswith="Goodbye")
+ ),
+ ["Hello", "Goodbye", "Hello and goodbye"],
+ attrgetter("headline"),
+ )
+
+ self.assertQuerySetEqual(
+ Article.objects.filter(headline__contains="Hello")
+ | Article.objects.filter(headline__contains="bye"),
+ ["Hello", "Goodbye", "Hello and goodbye"],
+ attrgetter("headline"),
+ )
+
+ self.assertQuerySetEqual(
+ Article.objects.filter(headline__iexact="Hello")
+ | Article.objects.filter(headline__contains="ood"),
+ ["Hello", "Goodbye", "Hello and goodbye"],
+ attrgetter("headline"),
+ )
+
+ self.assertQuerySetEqual(
+ Article.objects.filter(
+ Q(headline__startswith="Hello") | Q(headline__startswith="Goodbye")
+ ),
+ ["Hello", "Goodbye", "Hello and goodbye"],
+ attrgetter("headline"),
+ )
+
+ def test_stages(self):
+ # You can shorten this syntax with code like the following, which is
+ # especially useful if building the query in stages:
+ articles = Article.objects.all()
+ self.assertQuerySetEqual(
+ articles.filter(headline__startswith="Hello")
+ & articles.filter(headline__startswith="Goodbye"),
+ [],
+ )
+ self.assertQuerySetEqual(
+ articles.filter(headline__startswith="Hello")
+ & articles.filter(headline__contains="bye"),
+ ["Hello and goodbye"],
+ attrgetter("headline"),
+ )
+
+ def test_pk_q(self):
+ self.assertQuerySetEqual(
+ Article.objects.filter(Q(pk=self.a1) | Q(pk=self.a2)),
+ ["Hello", "Goodbye"],
+ attrgetter("headline"),
+ )
+
+ self.assertQuerySetEqual(
+ Article.objects.filter(Q(pk=self.a1) | Q(pk=self.a2) | Q(pk=self.a3)),
+ ["Hello", "Goodbye", "Hello and goodbye"],
+ attrgetter("headline"),
+ )
+
+ def test_pk_in(self):
+ self.assertQuerySetEqual(
+ Article.objects.filter(pk__in=[self.a1, self.a2, self.a3]),
+ ["Hello", "Goodbye", "Hello and goodbye"],
+ attrgetter("headline"),
+ )
+
+ self.assertQuerySetEqual(
+ Article.objects.filter(pk__in=(self.a1, self.a2, self.a3)),
+ ["Hello", "Goodbye", "Hello and goodbye"],
+ attrgetter("headline"),
+ )
+
+ self.assertQuerySetEqual(
+ Article.objects.filter(pk__in=[self.a1, self.a2, self.a3, 40000]),
+ ["Hello", "Goodbye", "Hello and goodbye"],
+ attrgetter("headline"),
+ )
+
+ def test_q_repr(self):
+ or_expr = Q(baz=Article(headline="Foö"))
+ self.assertEqual(repr(or_expr), "))>")
+ negated_or = ~Q(baz=Article(headline="Foö"))
+ self.assertEqual(repr(negated_or), ")))>")
+
+ def test_q_negated(self):
+ # Q objects can be negated
+ self.assertQuerySetEqual(
+ Article.objects.filter(Q(pk=self.a1) | ~Q(pk=self.a2)),
+ ["Hello", "Hello and goodbye"],
+ attrgetter("headline"),
+ )
+
+ self.assertQuerySetEqual(
+ Article.objects.filter(~Q(pk=self.a1) & ~Q(pk=self.a2)),
+ ["Hello and goodbye"],
+ attrgetter("headline"),
+ )
+ # This allows for more complex queries than filter() and exclude()
+ # alone would allow
+ self.assertQuerySetEqual(
+ Article.objects.filter(Q(pk=self.a1) & (~Q(pk=self.a2) | Q(pk=self.a3))),
+ ["Hello"],
+ attrgetter("headline"),
+ )
+
+ def test_complex_filter(self):
+ # The 'complex_filter' method supports framework features such as
+ # 'limit_choices_to' which normally take a single dictionary of lookup
+ # arguments but need to support arbitrary queries via Q objects too.
+ self.assertQuerySetEqual(
+ Article.objects.complex_filter({"pk": self.a1}),
+ ["Hello"],
+ attrgetter("headline"),
+ )
+
+ self.assertQuerySetEqual(
+ Article.objects.complex_filter(Q(pk=self.a1) | Q(pk=self.a2)),
+ ["Hello", "Goodbye"],
+ attrgetter("headline"),
+ )
+
+ def test_empty_in(self):
+ # Passing "in" an empty list returns no results ...
+ self.assertQuerySetEqual(Article.objects.filter(pk__in=[]), [])
+ # ... but can return results if we OR it with another query.
+ self.assertQuerySetEqual(
+ Article.objects.filter(Q(pk__in=[]) | Q(headline__icontains="goodbye")),
+ ["Goodbye", "Hello and goodbye"],
+ attrgetter("headline"),
+ )
+
+ def test_q_and(self):
+ # Q arg objects are ANDed
+ self.assertQuerySetEqual(
+ Article.objects.filter(
+ Q(headline__startswith="Hello"), Q(headline__contains="bye")
+ ),
+ ["Hello and goodbye"],
+ attrgetter("headline"),
+ )
+ # Q arg AND order is irrelevant
+ self.assertQuerySetEqual(
+ Article.objects.filter(
+ Q(headline__contains="bye"), headline__startswith="Hello"
+ ),
+ ["Hello and goodbye"],
+ attrgetter("headline"),
+ )
+
+ self.assertQuerySetEqual(
+ Article.objects.filter(
+ Q(headline__startswith="Hello") & Q(headline__startswith="Goodbye")
+ ),
+ [],
+ )
+
+ def test_q_exclude(self):
+ self.assertQuerySetEqual(
+ Article.objects.exclude(Q(headline__startswith="Hello")),
+ ["Goodbye"],
+ attrgetter("headline"),
+ )
+
+ def test_other_arg_queries(self):
+ # Try some arg queries with operations other than filter.
+ self.assertEqual(
+ Article.objects.get(
+ Q(headline__startswith="Hello"), Q(headline__contains="bye")
+ ).headline,
+ "Hello and goodbye",
+ )
+
+ self.assertEqual(
+ Article.objects.filter(
+ Q(headline__startswith="Hello") | Q(headline__contains="bye")
+ ).count(),
+ 3,
+ )
+
+ self.assertSequenceEqual(
+ Article.objects.filter(
+ Q(headline__startswith="Hello"), Q(headline__contains="bye")
+ ).values(),
+ [
+ {
+ "headline": "Hello and goodbye",
+ "id": self.a3,
+ "pub_date": datetime(2005, 11, 29),
+ },
+ ],
+ )
+
+ self.assertEqual(
+ Article.objects.filter(Q(headline__startswith="Hello")).in_bulk(
+ [self.a1, self.a2]
+ ),
+ {self.a1: Article.objects.get(pk=self.a1)},
+ )
diff --git a/testbed/django__django/tests/order_with_respect_to/__init__.py b/testbed/django__django/tests/order_with_respect_to/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testbed/django__django/tests/order_with_respect_to/base_tests.py b/testbed/django__django/tests/order_with_respect_to/base_tests.py
new file mode 100644
index 0000000000000000000000000000000000000000..ea548ca076e4d12493d811982ae13ff6f5affa8a
--- /dev/null
+++ b/testbed/django__django/tests/order_with_respect_to/base_tests.py
@@ -0,0 +1,124 @@
+"""
+The tests are shared with contenttypes_tests and so shouldn't import or
+reference any models directly. Subclasses should inherit django.test.TestCase.
+"""
+from operator import attrgetter
+
+
+class BaseOrderWithRespectToTests:
+ databases = {"default", "other"}
+
+ # Hook to allow subclasses to run these tests with alternate models.
+ Answer = None
+ Post = None
+ Question = None
+
+ @classmethod
+ def setUpTestData(cls):
+ cls.q1 = cls.Question.objects.create(
+ text="Which Beatle starts with the letter 'R'?"
+ )
+ cls.Answer.objects.create(text="John", question=cls.q1)
+ cls.Answer.objects.create(text="Paul", question=cls.q1)
+ cls.Answer.objects.create(text="George", question=cls.q1)
+ cls.Answer.objects.create(text="Ringo", question=cls.q1)
+
+ def test_default_to_insertion_order(self):
+ # Answers will always be ordered in the order they were inserted.
+ self.assertQuerySetEqual(
+ self.q1.answer_set.all(),
+ [
+ "John",
+ "Paul",
+ "George",
+ "Ringo",
+ ],
+ attrgetter("text"),
+ )
+
+ def test_previous_and_next_in_order(self):
+ # We can retrieve the answers related to a particular object, in the
+ # order they were created, once we have a particular object.
+ a1 = self.q1.answer_set.all()[0]
+ self.assertEqual(a1.text, "John")
+ self.assertEqual(a1.get_next_in_order().text, "Paul")
+
+ a2 = list(self.q1.answer_set.all())[-1]
+ self.assertEqual(a2.text, "Ringo")
+ self.assertEqual(a2.get_previous_in_order().text, "George")
+
+ def test_item_ordering(self):
+ # We can retrieve the ordering of the queryset from a particular item.
+ a1 = self.q1.answer_set.all()[1]
+ id_list = [o.pk for o in self.q1.answer_set.all()]
+ self.assertSequenceEqual(a1.question.get_answer_order(), id_list)
+
+ # It doesn't matter which answer we use to check the order, it will
+ # always be the same.
+ a2 = self.Answer.objects.create(text="Number five", question=self.q1)
+ self.assertEqual(
+ list(a1.question.get_answer_order()), list(a2.question.get_answer_order())
+ )
+
+ def test_set_order_unrelated_object(self):
+ """An answer that's not related isn't updated."""
+ q = self.Question.objects.create(text="other")
+ a = self.Answer.objects.create(text="Number five", question=q)
+ self.q1.set_answer_order([o.pk for o in self.q1.answer_set.all()] + [a.pk])
+ self.assertEqual(self.Answer.objects.get(pk=a.pk)._order, 0)
+
+ def test_change_ordering(self):
+ # The ordering can be altered
+ a = self.Answer.objects.create(text="Number five", question=self.q1)
+
+ # Swap the last two items in the order list
+ id_list = [o.pk for o in self.q1.answer_set.all()]
+ x = id_list.pop()
+ id_list.insert(-1, x)
+
+ # By default, the ordering is different from the swapped version
+ self.assertNotEqual(list(a.question.get_answer_order()), id_list)
+
+ # Change the ordering to the swapped version -
+ # this changes the ordering of the queryset.
+ a.question.set_answer_order(id_list)
+ self.assertQuerySetEqual(
+ self.q1.answer_set.all(),
+ ["John", "Paul", "George", "Number five", "Ringo"],
+ attrgetter("text"),
+ )
+
+ def test_recursive_ordering(self):
+ p1 = self.Post.objects.create(title="1")
+ p2 = self.Post.objects.create(title="2")
+ p1_1 = self.Post.objects.create(title="1.1", parent=p1)
+ p1_2 = self.Post.objects.create(title="1.2", parent=p1)
+ self.Post.objects.create(title="2.1", parent=p2)
+ p1_3 = self.Post.objects.create(title="1.3", parent=p1)
+ self.assertSequenceEqual(p1.get_post_order(), [p1_1.pk, p1_2.pk, p1_3.pk])
+
+ def test_delete_and_insert(self):
+ q1 = self.Question.objects.create(text="What is your favorite color?")
+ q2 = self.Question.objects.create(text="What color is it?")
+ a1 = self.Answer.objects.create(text="Blue", question=q1)
+ a2 = self.Answer.objects.create(text="Red", question=q1)
+ a3 = self.Answer.objects.create(text="Green", question=q1)
+ a4 = self.Answer.objects.create(text="Yellow", question=q1)
+ self.assertSequenceEqual(q1.answer_set.all(), [a1, a2, a3, a4])
+ a3.question = q2
+ a3.save()
+ a1.delete()
+ new_answer = self.Answer.objects.create(text="Black", question=q1)
+ self.assertSequenceEqual(q1.answer_set.all(), [a2, a4, new_answer])
+
+ def test_database_routing(self):
+ class WriteToOtherRouter:
+ def db_for_write(self, model, **hints):
+ return "other"
+
+ with self.settings(DATABASE_ROUTERS=[WriteToOtherRouter()]):
+ with self.assertNumQueries(0, using="default"), self.assertNumQueries(
+ 1,
+ using="other",
+ ):
+ self.q1.set_answer_order([3, 1, 2, 4])
diff --git a/testbed/django__django/tests/order_with_respect_to/models.py b/testbed/django__django/tests/order_with_respect_to/models.py
new file mode 100644
index 0000000000000000000000000000000000000000..7b3e8da3fa0ad861579734a087c789565f5dd03f
--- /dev/null
+++ b/testbed/django__django/tests/order_with_respect_to/models.py
@@ -0,0 +1,49 @@
+"""
+Tests for the order_with_respect_to Meta attribute.
+"""
+
+from django.db import models
+
+
+class Question(models.Model):
+ text = models.CharField(max_length=200)
+
+
+class Answer(models.Model):
+ text = models.CharField(max_length=200)
+ question = models.ForeignKey(Question, models.CASCADE)
+
+ class Meta:
+ order_with_respect_to = "question"
+
+ def __str__(self):
+ return self.text
+
+
+class Post(models.Model):
+ title = models.CharField(max_length=200)
+ parent = models.ForeignKey(
+ "self", models.SET_NULL, related_name="children", null=True
+ )
+
+ class Meta:
+ order_with_respect_to = "parent"
+
+ def __str__(self):
+ return self.title
+
+
+# order_with_respect_to points to a model with a OneToOneField primary key.
+class Entity(models.Model):
+ pass
+
+
+class Dimension(models.Model):
+ entity = models.OneToOneField("Entity", primary_key=True, on_delete=models.CASCADE)
+
+
+class Component(models.Model):
+ dimension = models.ForeignKey("Dimension", on_delete=models.CASCADE)
+
+ class Meta:
+ order_with_respect_to = "dimension"
diff --git a/testbed/django__django/tests/ordering/__init__.py b/testbed/django__django/tests/ordering/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testbed/django__django/tests/ordering/models.py b/testbed/django__django/tests/ordering/models.py
new file mode 100644
index 0000000000000000000000000000000000000000..c365da76423cbd453e7126a3a19663579725ff49
--- /dev/null
+++ b/testbed/django__django/tests/ordering/models.py
@@ -0,0 +1,82 @@
+"""
+Specifying ordering
+
+Specify default ordering for a model using the ``ordering`` attribute, which
+should be a list or tuple of field names. This tells Django how to order
+``QuerySet`` results.
+
+If a field name in ``ordering`` starts with a hyphen, that field will be
+ordered in descending order. Otherwise, it'll be ordered in ascending order.
+The special-case field name ``"?"`` specifies random order.
+
+The ordering attribute is not required. If you leave it off, ordering will be
+undefined -- not random, just undefined.
+"""
+
+from django.db import models
+
+
+class Author(models.Model):
+ name = models.CharField(max_length=63, null=True, blank=True)
+ editor = models.ForeignKey("self", models.CASCADE, null=True)
+
+ class Meta:
+ ordering = ("-pk",)
+
+
+class Article(models.Model):
+ author = models.ForeignKey(Author, models.SET_NULL, null=True)
+ second_author = models.ForeignKey(
+ Author, models.SET_NULL, null=True, related_name="+"
+ )
+ headline = models.CharField(max_length=100)
+ pub_date = models.DateTimeField()
+
+ class Meta:
+ ordering = (
+ "-pub_date",
+ models.F("headline"),
+ models.F("author__name").asc(),
+ models.OrderBy(models.F("second_author__name")),
+ )
+
+
+class OrderedByAuthorArticle(Article):
+ class Meta:
+ proxy = True
+ ordering = ("author", "second_author")
+
+
+class OrderedByFArticle(Article):
+ class Meta:
+ proxy = True
+ ordering = (models.F("author").asc(nulls_first=True), "id")
+
+
+class ChildArticle(Article):
+ pass
+
+
+class Reference(models.Model):
+ article = models.ForeignKey(OrderedByAuthorArticle, models.CASCADE)
+
+ class Meta:
+ ordering = ("article",)
+
+
+class OrderedByExpression(models.Model):
+ name = models.CharField(max_length=30)
+
+ class Meta:
+ ordering = [models.functions.Lower("name")]
+
+
+class OrderedByExpressionChild(models.Model):
+ parent = models.ForeignKey(OrderedByExpression, models.CASCADE)
+
+ class Meta:
+ ordering = ["parent"]
+
+
+class OrderedByExpressionGrandChild(models.Model):
+ parent = models.ForeignKey(OrderedByExpressionChild, models.CASCADE)
diff --git a/testbed/django__django/tests/ordering/tests.py b/testbed/django__django/tests/ordering/tests.py
new file mode 100644
index 0000000000000000000000000000000000000000..b29404ed77da8f2ac7051cf837570eae84e0065c
--- /dev/null
+++ b/testbed/django__django/tests/ordering/tests.py
@@ -0,0 +1,646 @@
+from datetime import datetime
+from operator import attrgetter
+
+from django.core.exceptions import FieldError
+from django.db.models import (
+ CharField,
+ Count,
+ DateTimeField,
+ F,
+ Max,
+ OrderBy,
+ OuterRef,
+ Subquery,
+ Value,
+)
+from django.db.models.functions import Length, Upper
+from django.test import TestCase
+
+from .models import (
+ Article,
+ Author,
+ ChildArticle,
+ OrderedByExpression,
+ OrderedByExpressionChild,
+ OrderedByExpressionGrandChild,
+ OrderedByFArticle,
+ Reference,
+)
+
+
+class OrderingTests(TestCase):
+ @classmethod
+ def setUpTestData(cls):
+ cls.a1 = Article.objects.create(
+ headline="Article 1", pub_date=datetime(2005, 7, 26)
+ )
+ cls.a2 = Article.objects.create(
+ headline="Article 2", pub_date=datetime(2005, 7, 27)
+ )
+ cls.a3 = Article.objects.create(
+ headline="Article 3", pub_date=datetime(2005, 7, 27)
+ )
+ cls.a4 = Article.objects.create(
+ headline="Article 4", pub_date=datetime(2005, 7, 28)
+ )
+ cls.author_1 = Author.objects.create(name="Name 1")
+ cls.author_2 = Author.objects.create(name="Name 2")
+ for i in range(2):
+ Author.objects.create()
+
+ def test_default_ordering(self):
+ """
+ By default, Article.objects.all() orders by pub_date descending, then
+ headline ascending.
+ """
+ self.assertQuerySetEqual(
+ Article.objects.all(),
+ [
+ "Article 4",
+ "Article 2",
+ "Article 3",
+ "Article 1",
+ ],
+ attrgetter("headline"),
+ )
+
+ # Getting a single item should work too:
+ self.assertEqual(Article.objects.all()[0], self.a4)
+
+ def test_default_ordering_override(self):
+ """
+ Override ordering with order_by, which is in the same format as the
+ ordering attribute in models.
+ """
+ self.assertQuerySetEqual(
+ Article.objects.order_by("headline"),
+ [
+ "Article 1",
+ "Article 2",
+ "Article 3",
+ "Article 4",
+ ],
+ attrgetter("headline"),
+ )
+ self.assertQuerySetEqual(
+ Article.objects.order_by("pub_date", "-headline"),
+ [
+ "Article 1",
+ "Article 3",
+ "Article 2",
+ "Article 4",
+ ],
+ attrgetter("headline"),
+ )
+
+ def test_default_ordering_override_unknown_field(self):
+ """
+ Attempts to override default ordering on related models with an unknown
+ field should result in an error.
+ """
+ msg = (
+ "Cannot resolve keyword 'unknown_field' into field. Choices are: "
+ "article, author, editor, editor_id, id, name"
+ )
+ with self.assertRaisesMessage(FieldError, msg):
+ list(Article.objects.order_by("author__unknown_field"))
+
+ def test_order_by_override(self):
+ """
+ Only the last order_by has any effect (since they each override any
+ previous ordering).
+ """
+ self.assertQuerySetEqual(
+ Article.objects.order_by("id"),
+ [
+ "Article 1",
+ "Article 2",
+ "Article 3",
+ "Article 4",
+ ],
+ attrgetter("headline"),
+ )
+ self.assertQuerySetEqual(
+ Article.objects.order_by("id").order_by("-headline"),
+ [
+ "Article 4",
+ "Article 3",
+ "Article 2",
+ "Article 1",
+ ],
+ attrgetter("headline"),
+ )
+
+ def test_order_by_nulls_first_and_last(self):
+ msg = "nulls_first and nulls_last are mutually exclusive"
+ with self.assertRaisesMessage(ValueError, msg):
+ Article.objects.order_by(
+ F("author").desc(nulls_last=True, nulls_first=True)
+ )
+
+ def assertQuerySetEqualReversible(self, queryset, sequence):
+ self.assertSequenceEqual(queryset, sequence)
+ self.assertSequenceEqual(queryset.reverse(), list(reversed(sequence)))
+
+ def test_order_by_nulls_last(self):
+ Article.objects.filter(headline="Article 3").update(author=self.author_1)
+ Article.objects.filter(headline="Article 4").update(author=self.author_2)
+ # asc and desc are chainable with nulls_last.
+ self.assertQuerySetEqualReversible(
+ Article.objects.order_by(F("author").desc(nulls_last=True), "headline"),
+ [self.a4, self.a3, self.a1, self.a2],
+ )
+ self.assertQuerySetEqualReversible(
+ Article.objects.order_by(F("author").asc(nulls_last=True), "headline"),
+ [self.a3, self.a4, self.a1, self.a2],
+ )
+ self.assertQuerySetEqualReversible(
+ Article.objects.order_by(
+ Upper("author__name").desc(nulls_last=True), "headline"
+ ),
+ [self.a4, self.a3, self.a1, self.a2],
+ )
+ self.assertQuerySetEqualReversible(
+ Article.objects.order_by(
+ Upper("author__name").asc(nulls_last=True), "headline"
+ ),
+ [self.a3, self.a4, self.a1, self.a2],
+ )
+ self.assertQuerySetEqualReversible(
+ Article.objects.annotate(upper_name=Upper("author__name")).order_by(
+ F("upper_name").asc(nulls_last=True), "headline"
+ ),
+ [self.a3, self.a4, self.a1, self.a2],
+ )
+
+ def test_order_by_nulls_first(self):
+ Article.objects.filter(headline="Article 3").update(author=self.author_1)
+ Article.objects.filter(headline="Article 4").update(author=self.author_2)
+ # asc and desc are chainable with nulls_first.
+ self.assertQuerySetEqualReversible(
+ Article.objects.order_by(F("author").asc(nulls_first=True), "headline"),
+ [self.a1, self.a2, self.a3, self.a4],
+ )
+ self.assertQuerySetEqualReversible(
+ Article.objects.order_by(F("author").desc(nulls_first=True), "headline"),
+ [self.a1, self.a2, self.a4, self.a3],
+ )
+ self.assertQuerySetEqualReversible(
+ Article.objects.order_by(
+ Upper("author__name").asc(nulls_first=True), "headline"
+ ),
+ [self.a1, self.a2, self.a3, self.a4],
+ )
+ self.assertQuerySetEqualReversible(
+ Article.objects.order_by(
+ Upper("author__name").desc(nulls_first=True), "headline"
+ ),
+ [self.a1, self.a2, self.a4, self.a3],
+ )
+ self.assertQuerySetEqualReversible(
+ Article.objects.annotate(upper_name=Upper("author__name")).order_by(
+ F("upper_name").desc(nulls_first=True), "headline"
+ ),
+ [self.a1, self.a2, self.a4, self.a3],
+ )
+
+ def test_orders_nulls_first_on_filtered_subquery(self):
+ Article.objects.filter(headline="Article 1").update(author=self.author_1)
+ Article.objects.filter(headline="Article 2").update(author=self.author_1)
+ Article.objects.filter(headline="Article 4").update(author=self.author_2)
+ Author.objects.filter(name__isnull=True).delete()
+ author_3 = Author.objects.create(name="Name 3")
+ article_subquery = (
+ Article.objects.filter(
+ author=OuterRef("pk"),
+ headline__icontains="Article",
+ )
+ .order_by()
+ .values("author")
+ .annotate(
+ last_date=Max("pub_date"),
+ )
+ .values("last_date")
+ )
+ self.assertQuerySetEqualReversible(
+ Author.objects.annotate(
+ last_date=Subquery(article_subquery, output_field=DateTimeField())
+ )
+ .order_by(F("last_date").asc(nulls_first=True))
+ .distinct(),
+ [author_3, self.author_1, self.author_2],
+ )
+
+ def test_stop_slicing(self):
+ """
+ Use the 'stop' part of slicing notation to limit the results.
+ """
+ self.assertQuerySetEqual(
+ Article.objects.order_by("headline")[:2],
+ [
+ "Article 1",
+ "Article 2",
+ ],
+ attrgetter("headline"),
+ )
+
+ def test_stop_start_slicing(self):
+ """
+ Use the 'stop' and 'start' parts of slicing notation to offset the
+ result list.
+ """
+ self.assertQuerySetEqual(
+ Article.objects.order_by("headline")[1:3],
+ [
+ "Article 2",
+ "Article 3",
+ ],
+ attrgetter("headline"),
+ )
+
+ def test_random_ordering(self):
+ """
+ Use '?' to order randomly.
+ """
+ self.assertEqual(len(list(Article.objects.order_by("?"))), 4)
+
+ def test_reversed_ordering(self):
+ """
+ Ordering can be reversed using the reverse() method on a queryset.
+ This allows you to extract things like "the last two items" (reverse
+ and then take the first two).
+ """
+ self.assertQuerySetEqual(
+ Article.objects.reverse()[:2],
+ [
+ "Article 1",
+ "Article 3",
+ ],
+ attrgetter("headline"),
+ )
+
+ def test_reverse_ordering_pure(self):
+ qs1 = Article.objects.order_by(F("headline").asc())
+ qs2 = qs1.reverse()
+ self.assertQuerySetEqual(
+ qs2,
+ [
+ "Article 4",
+ "Article 3",
+ "Article 2",
+ "Article 1",
+ ],
+ attrgetter("headline"),
+ )
+ self.assertQuerySetEqual(
+ qs1,
+ [
+ "Article 1",
+ "Article 2",
+ "Article 3",
+ "Article 4",
+ ],
+ attrgetter("headline"),
+ )
+
+ def test_reverse_meta_ordering_pure(self):
+ Article.objects.create(
+ headline="Article 5",
+ pub_date=datetime(2005, 7, 30),
+ author=self.author_1,
+ second_author=self.author_2,
+ )
+ Article.objects.create(
+ headline="Article 5",
+ pub_date=datetime(2005, 7, 30),
+ author=self.author_2,
+ second_author=self.author_1,
+ )
+ self.assertQuerySetEqual(
+ Article.objects.filter(headline="Article 5").reverse(),
+ ["Name 2", "Name 1"],
+ attrgetter("author.name"),
+ )
+ self.assertQuerySetEqual(
+ Article.objects.filter(headline="Article 5"),
+ ["Name 1", "Name 2"],
+ attrgetter("author.name"),
+ )
+
+ def test_no_reordering_after_slicing(self):
+ msg = "Cannot reverse a query once a slice has been taken."
+ qs = Article.objects.all()[0:2]
+ with self.assertRaisesMessage(TypeError, msg):
+ qs.reverse()
+ with self.assertRaisesMessage(TypeError, msg):
+ qs.last()
+
+ def test_extra_ordering(self):
+ """
+ Ordering can be based on fields included from an 'extra' clause
+ """
+ self.assertQuerySetEqual(
+ Article.objects.extra(
+ select={"foo": "pub_date"}, order_by=["foo", "headline"]
+ ),
+ [
+ "Article 1",
+ "Article 2",
+ "Article 3",
+ "Article 4",
+ ],
+ attrgetter("headline"),
+ )
+
+ def test_extra_ordering_quoting(self):
+ """
+ If the extra clause uses an SQL keyword for a name, it will be
+ protected by quoting.
+ """
+ self.assertQuerySetEqual(
+ Article.objects.extra(
+ select={"order": "pub_date"}, order_by=["order", "headline"]
+ ),
+ [
+ "Article 1",
+ "Article 2",
+ "Article 3",
+ "Article 4",
+ ],
+ attrgetter("headline"),
+ )
+
+ def test_extra_ordering_with_table_name(self):
+ self.assertQuerySetEqual(
+ Article.objects.extra(order_by=["ordering_article.headline"]),
+ [
+ "Article 1",
+ "Article 2",
+ "Article 3",
+ "Article 4",
+ ],
+ attrgetter("headline"),
+ )
+ self.assertQuerySetEqual(
+ Article.objects.extra(order_by=["-ordering_article.headline"]),
+ [
+ "Article 4",
+ "Article 3",
+ "Article 2",
+ "Article 1",
+ ],
+ attrgetter("headline"),
+ )
+
+ def test_order_by_pk(self):
+ """
+ 'pk' works as an ordering option in Meta.
+ """
+ self.assertEqual(
+ [a.pk for a in Author.objects.all()],
+ [a.pk for a in Author.objects.order_by("-pk")],
+ )
+
+ def test_order_by_fk_attname(self):
+ """
+ ordering by a foreign key by its attribute name prevents the query
+ from inheriting its related model ordering option (#19195).
+ """
+ authors = list(Author.objects.order_by("id"))
+ for i in range(1, 5):
+ author = authors[i - 1]
+ article = getattr(self, "a%d" % (5 - i))
+ article.author = author
+ article.save(update_fields={"author"})
+
+ self.assertQuerySetEqual(
+ Article.objects.order_by("author_id"),
+ [
+ "Article 4",
+ "Article 3",
+ "Article 2",
+ "Article 1",
+ ],
+ attrgetter("headline"),
+ )
+
+ def test_order_by_self_referential_fk(self):
+ self.a1.author = Author.objects.create(editor=self.author_1)
+ self.a1.save()
+ self.a2.author = Author.objects.create(editor=self.author_2)
+ self.a2.save()
+ self.assertQuerySetEqual(
+ Article.objects.filter(author__isnull=False).order_by("author__editor"),
+ ["Article 2", "Article 1"],
+ attrgetter("headline"),
+ )
+ self.assertQuerySetEqual(
+ Article.objects.filter(author__isnull=False).order_by("author__editor_id"),
+ ["Article 1", "Article 2"],
+ attrgetter("headline"),
+ )
+
+ def test_order_by_f_expression(self):
+ self.assertQuerySetEqual(
+ Article.objects.order_by(F("headline")),
+ [
+ "Article 1",
+ "Article 2",
+ "Article 3",
+ "Article 4",
+ ],
+ attrgetter("headline"),
+ )
+ self.assertQuerySetEqual(
+ Article.objects.order_by(F("headline").asc()),
+ [
+ "Article 1",
+ "Article 2",
+ "Article 3",
+ "Article 4",
+ ],
+ attrgetter("headline"),
+ )
+ self.assertQuerySetEqual(
+ Article.objects.order_by(F("headline").desc()),
+ [
+ "Article 4",
+ "Article 3",
+ "Article 2",
+ "Article 1",
+ ],
+ attrgetter("headline"),
+ )
+
+ def test_order_by_f_expression_duplicates(self):
+ """
+ A column may only be included once (the first occurrence) so we check
+ to ensure there are no duplicates by inspecting the SQL.
+ """
+ qs = Article.objects.order_by(F("headline").asc(), F("headline").desc())
+ sql = str(qs.query).upper()
+ fragment = sql[sql.find("ORDER BY") :]
+ self.assertEqual(fragment.count("HEADLINE"), 1)
+ self.assertQuerySetEqual(
+ qs,
+ [
+ "Article 1",
+ "Article 2",
+ "Article 3",
+ "Article 4",
+ ],
+ attrgetter("headline"),
+ )
+ qs = Article.objects.order_by(F("headline").desc(), F("headline").asc())
+ sql = str(qs.query).upper()
+ fragment = sql[sql.find("ORDER BY") :]
+ self.assertEqual(fragment.count("HEADLINE"), 1)
+ self.assertQuerySetEqual(
+ qs,
+ [
+ "Article 4",
+ "Article 3",
+ "Article 2",
+ "Article 1",
+ ],
+ attrgetter("headline"),
+ )
+
+ def test_order_by_constant_value(self):
+ # Order by annotated constant from selected columns.
+ qs = Article.objects.annotate(
+ constant=Value("1", output_field=CharField()),
+ ).order_by("constant", "-headline")
+ self.assertSequenceEqual(qs, [self.a4, self.a3, self.a2, self.a1])
+ # Order by annotated constant which is out of selected columns.
+ self.assertSequenceEqual(
+ qs.values_list("headline", flat=True),
+ [
+ "Article 4",
+ "Article 3",
+ "Article 2",
+ "Article 1",
+ ],
+ )
+ # Order by constant.
+ qs = Article.objects.order_by(Value("1", output_field=CharField()), "-headline")
+ self.assertSequenceEqual(qs, [self.a4, self.a3, self.a2, self.a1])
+
+ def test_related_ordering_duplicate_table_reference(self):
+ """
+ An ordering referencing a model with an ordering referencing a model
+ multiple time no circular reference should be detected (#24654).
+ """
+ first_author = Author.objects.create()
+ second_author = Author.objects.create()
+ self.a1.author = first_author
+ self.a1.second_author = second_author
+ self.a1.save()
+ self.a2.author = second_author
+ self.a2.second_author = first_author
+ self.a2.save()
+ r1 = Reference.objects.create(article_id=self.a1.pk)
+ r2 = Reference.objects.create(article_id=self.a2.pk)
+ self.assertSequenceEqual(Reference.objects.all(), [r2, r1])
+
+ def test_default_ordering_by_f_expression(self):
+ """F expressions can be used in Meta.ordering."""
+ articles = OrderedByFArticle.objects.all()
+ articles.filter(headline="Article 2").update(author=self.author_2)
+ articles.filter(headline="Article 3").update(author=self.author_1)
+ self.assertQuerySetEqual(
+ articles,
+ ["Article 1", "Article 4", "Article 3", "Article 2"],
+ attrgetter("headline"),
+ )
+
+ def test_order_by_ptr_field_with_default_ordering_by_expression(self):
+ ca1 = ChildArticle.objects.create(
+ headline="h2",
+ pub_date=datetime(2005, 7, 27),
+ author=self.author_2,
+ )
+ ca2 = ChildArticle.objects.create(
+ headline="h2",
+ pub_date=datetime(2005, 7, 27),
+ author=self.author_1,
+ )
+ ca3 = ChildArticle.objects.create(
+ headline="h3",
+ pub_date=datetime(2005, 7, 27),
+ author=self.author_1,
+ )
+ ca4 = ChildArticle.objects.create(headline="h1", pub_date=datetime(2005, 7, 28))
+ articles = ChildArticle.objects.order_by("article_ptr")
+ self.assertSequenceEqual(articles, [ca4, ca2, ca1, ca3])
+
+ def test_default_ordering_does_not_affect_group_by(self):
+ Article.objects.exclude(headline="Article 4").update(author=self.author_1)
+ Article.objects.filter(headline="Article 4").update(author=self.author_2)
+ articles = Article.objects.values("author").annotate(count=Count("author"))
+ self.assertCountEqual(
+ articles,
+ [
+ {"author": self.author_1.pk, "count": 3},
+ {"author": self.author_2.pk, "count": 1},
+ ],
+ )
+
+ def test_order_by_parent_fk_with_expression_in_default_ordering(self):
+ p3 = OrderedByExpression.objects.create(name="oBJ 3")
+ p2 = OrderedByExpression.objects.create(name="OBJ 2")
+ p1 = OrderedByExpression.objects.create(name="obj 1")
+ c3 = OrderedByExpressionChild.objects.create(parent=p3)
+ c2 = OrderedByExpressionChild.objects.create(parent=p2)
+ c1 = OrderedByExpressionChild.objects.create(parent=p1)
+ self.assertSequenceEqual(
+ OrderedByExpressionChild.objects.order_by("parent"),
+ [c1, c2, c3],
+ )
+
+ def test_order_by_grandparent_fk_with_expression_in_default_ordering(self):
+ p3 = OrderedByExpression.objects.create(name="oBJ 3")
+ p2 = OrderedByExpression.objects.create(name="OBJ 2")
+ p1 = OrderedByExpression.objects.create(name="obj 1")
+ c3 = OrderedByExpressionChild.objects.create(parent=p3)
+ c2 = OrderedByExpressionChild.objects.create(parent=p2)
+ c1 = OrderedByExpressionChild.objects.create(parent=p1)
+ g3 = OrderedByExpressionGrandChild.objects.create(parent=c3)
+ g2 = OrderedByExpressionGrandChild.objects.create(parent=c2)
+ g1 = OrderedByExpressionGrandChild.objects.create(parent=c1)
+ self.assertSequenceEqual(
+ OrderedByExpressionGrandChild.objects.order_by("parent"),
+ [g1, g2, g3],
+ )
+
+ def test_order_by_expression_ref(self):
+ self.assertQuerySetEqual(
+ Author.objects.annotate(upper_name=Upper("name")).order_by(
+ Length("upper_name")
+ ),
+ Author.objects.order_by(Length(Upper("name"))),
+ )
+
+ def test_ordering_select_related_collision(self):
+ self.assertEqual(
+ Article.objects.select_related("author")
+ .annotate(name=Upper("author__name"))
+ .filter(pk=self.a1.pk)
+ .order_by(OrderBy(F("name")))
+ .first(),
+ self.a1,
+ )
+ self.assertEqual(
+ Article.objects.select_related("author")
+ .annotate(name=Upper("author__name"))
+ .filter(pk=self.a1.pk)
+ .order_by("name")
+ .first(),
+ self.a1,
+ )
+
+ def test_order_by_expr_query_reuse(self):
+ qs = Author.objects.annotate(num=Count("article")).order_by(
+ F("num").desc(), "pk"
+ )
+ self.assertCountEqual(qs, qs.iterator())
diff --git a/testbed/django__django/tests/pagination/__init__.py b/testbed/django__django/tests/pagination/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testbed/django__django/tests/pagination/custom.py b/testbed/django__django/tests/pagination/custom.py
new file mode 100644
index 0000000000000000000000000000000000000000..ea04083576be529dc6f1a927349453c56fa2a7cc
--- /dev/null
+++ b/testbed/django__django/tests/pagination/custom.py
@@ -0,0 +1,18 @@
+from django.core.paginator import Page, Paginator
+
+
+class ValidAdjacentNumsPage(Page):
+ def next_page_number(self):
+ if not self.has_next():
+ return None
+ return super().next_page_number()
+
+ def previous_page_number(self):
+ if not self.has_previous():
+ return None
+ return super().previous_page_number()
+
+
+class ValidAdjacentNumsPaginator(Paginator):
+ def _get_page(self, *args, **kwargs):
+ return ValidAdjacentNumsPage(*args, **kwargs)
diff --git a/testbed/django__django/tests/pagination/models.py b/testbed/django__django/tests/pagination/models.py
new file mode 100644
index 0000000000000000000000000000000000000000..9c118068203904fd5bcfdfbe1da2585854ade7a8
--- /dev/null
+++ b/testbed/django__django/tests/pagination/models.py
@@ -0,0 +1,9 @@
+from django.db import models
+
+
+class Article(models.Model):
+ headline = models.CharField(max_length=100, default="Default headline")
+ pub_date = models.DateTimeField()
+
+ def __str__(self):
+ return self.headline
diff --git a/testbed/django__django/tests/pagination/tests.py b/testbed/django__django/tests/pagination/tests.py
new file mode 100644
index 0000000000000000000000000000000000000000..cf7ec61d3b6dc3075ea69154073af0e7e9c51dd6
--- /dev/null
+++ b/testbed/django__django/tests/pagination/tests.py
@@ -0,0 +1,585 @@
+import collections.abc
+import unittest.mock
+import warnings
+from datetime import datetime
+
+from django.core.paginator import (
+ EmptyPage,
+ InvalidPage,
+ PageNotAnInteger,
+ Paginator,
+ UnorderedObjectListWarning,
+)
+from django.test import SimpleTestCase, TestCase
+
+from .custom import ValidAdjacentNumsPaginator
+from .models import Article
+
+
+class PaginationTests(SimpleTestCase):
+ """
+ Tests for the Paginator and Page classes.
+ """
+
+ def check_paginator(self, params, output):
+ """
+ Helper method that instantiates a Paginator object from the passed
+ params and then checks that its attributes match the passed output.
+ """
+ count, num_pages, page_range = output
+ paginator = Paginator(*params)
+ self.check_attribute("count", paginator, count, params)
+ self.check_attribute("num_pages", paginator, num_pages, params)
+ self.check_attribute("page_range", paginator, page_range, params, coerce=list)
+
+ def check_attribute(self, name, paginator, expected, params, coerce=None):
+ """
+ Helper method that checks a single attribute and gives a nice error
+ message upon test failure.
+ """
+ got = getattr(paginator, name)
+ if coerce is not None:
+ got = coerce(got)
+ self.assertEqual(
+ expected,
+ got,
+ "For '%s', expected %s but got %s. Paginator parameters were: %s"
+ % (name, expected, got, params),
+ )
+
+ def test_paginator(self):
+ """
+ Tests the paginator attributes using varying inputs.
+ """
+ nine = [1, 2, 3, 4, 5, 6, 7, 8, 9]
+ ten = nine + [10]
+ eleven = ten + [11]
+ tests = (
+ # Each item is 2-tuple:
+ # First tuple is Paginator parameters - object_list, per_page,
+ # orphans, and allow_empty_first_page.
+ # Second tuple is resulting Paginator attributes - count,
+ # num_pages, and page_range.
+ # Ten items, varying orphans, no empty first page.
+ ((ten, 4, 0, False), (10, 3, [1, 2, 3])),
+ ((ten, 4, 1, False), (10, 3, [1, 2, 3])),
+ ((ten, 4, 2, False), (10, 2, [1, 2])),
+ ((ten, 4, 5, False), (10, 2, [1, 2])),
+ ((ten, 4, 6, False), (10, 1, [1])),
+ # Ten items, varying orphans, allow empty first page.
+ ((ten, 4, 0, True), (10, 3, [1, 2, 3])),
+ ((ten, 4, 1, True), (10, 3, [1, 2, 3])),
+ ((ten, 4, 2, True), (10, 2, [1, 2])),
+ ((ten, 4, 5, True), (10, 2, [1, 2])),
+ ((ten, 4, 6, True), (10, 1, [1])),
+ # One item, varying orphans, no empty first page.
+ (([1], 4, 0, False), (1, 1, [1])),
+ (([1], 4, 1, False), (1, 1, [1])),
+ (([1], 4, 2, False), (1, 1, [1])),
+ # One item, varying orphans, allow empty first page.
+ (([1], 4, 0, True), (1, 1, [1])),
+ (([1], 4, 1, True), (1, 1, [1])),
+ (([1], 4, 2, True), (1, 1, [1])),
+ # Zero items, varying orphans, no empty first page.
+ (([], 4, 0, False), (0, 0, [])),
+ (([], 4, 1, False), (0, 0, [])),
+ (([], 4, 2, False), (0, 0, [])),
+ # Zero items, varying orphans, allow empty first page.
+ (([], 4, 0, True), (0, 1, [1])),
+ (([], 4, 1, True), (0, 1, [1])),
+ (([], 4, 2, True), (0, 1, [1])),
+ # Number if items one less than per_page.
+ (([], 1, 0, True), (0, 1, [1])),
+ (([], 1, 0, False), (0, 0, [])),
+ (([1], 2, 0, True), (1, 1, [1])),
+ ((nine, 10, 0, True), (9, 1, [1])),
+ # Number if items equal to per_page.
+ (([1], 1, 0, True), (1, 1, [1])),
+ (([1, 2], 2, 0, True), (2, 1, [1])),
+ ((ten, 10, 0, True), (10, 1, [1])),
+ # Number if items one more than per_page.
+ (([1, 2], 1, 0, True), (2, 2, [1, 2])),
+ (([1, 2, 3], 2, 0, True), (3, 2, [1, 2])),
+ ((eleven, 10, 0, True), (11, 2, [1, 2])),
+ # Number if items one more than per_page with one orphan.
+ (([1, 2], 1, 1, True), (2, 1, [1])),
+ (([1, 2, 3], 2, 1, True), (3, 1, [1])),
+ ((eleven, 10, 1, True), (11, 1, [1])),
+ # Non-integer inputs
+ ((ten, "4", 1, False), (10, 3, [1, 2, 3])),
+ ((ten, "4", 1, False), (10, 3, [1, 2, 3])),
+ ((ten, 4, "1", False), (10, 3, [1, 2, 3])),
+ ((ten, 4, "1", False), (10, 3, [1, 2, 3])),
+ )
+ for params, output in tests:
+ self.check_paginator(params, output)
+
+ def test_invalid_page_number(self):
+ """
+ Invalid page numbers result in the correct exception being raised.
+ """
+ paginator = Paginator([1, 2, 3], 2)
+ with self.assertRaises(InvalidPage):
+ paginator.page(3)
+ with self.assertRaises(PageNotAnInteger):
+ paginator.validate_number(None)
+ with self.assertRaises(PageNotAnInteger):
+ paginator.validate_number("x")
+ with self.assertRaises(PageNotAnInteger):
+ paginator.validate_number(1.2)
+
+ def test_error_messages(self):
+ error_messages = {
+ "invalid_page": "Wrong page number",
+ "min_page": "Too small",
+ "no_results": "There is nothing here",
+ }
+ paginator = Paginator([1, 2, 3], 2, error_messages=error_messages)
+ msg = "Wrong page number"
+ with self.assertRaisesMessage(PageNotAnInteger, msg):
+ paginator.validate_number(1.2)
+ msg = "Too small"
+ with self.assertRaisesMessage(EmptyPage, msg):
+ paginator.validate_number(-1)
+ msg = "There is nothing here"
+ with self.assertRaisesMessage(EmptyPage, msg):
+ paginator.validate_number(3)
+
+ error_messages = {"min_page": "Too small"}
+ paginator = Paginator([1, 2, 3], 2, error_messages=error_messages)
+ # Custom message.
+ msg = "Too small"
+ with self.assertRaisesMessage(EmptyPage, msg):
+ paginator.validate_number(-1)
+ # Default message.
+ msg = "That page contains no results"
+ with self.assertRaisesMessage(EmptyPage, msg):
+ paginator.validate_number(3)
+
+ def test_float_integer_page(self):
+ paginator = Paginator([1, 2, 3], 2)
+ self.assertEqual(paginator.validate_number(1.0), 1)
+
+ def test_no_content_allow_empty_first_page(self):
+ # With no content and allow_empty_first_page=True, 1 is a valid page number
+ paginator = Paginator([], 2)
+ self.assertEqual(paginator.validate_number(1), 1)
+
+ def test_paginate_misc_classes(self):
+ class CountContainer:
+ def count(self):
+ return 42
+
+ # Paginator can be passed other objects with a count() method.
+ paginator = Paginator(CountContainer(), 10)
+ self.assertEqual(42, paginator.count)
+ self.assertEqual(5, paginator.num_pages)
+ self.assertEqual([1, 2, 3, 4, 5], list(paginator.page_range))
+
+ # Paginator can be passed other objects that implement __len__.
+ class LenContainer:
+ def __len__(self):
+ return 42
+
+ paginator = Paginator(LenContainer(), 10)
+ self.assertEqual(42, paginator.count)
+ self.assertEqual(5, paginator.num_pages)
+ self.assertEqual([1, 2, 3, 4, 5], list(paginator.page_range))
+
+ def test_count_does_not_silence_attribute_error(self):
+ class AttributeErrorContainer:
+ def count(self):
+ raise AttributeError("abc")
+
+ with self.assertRaisesMessage(AttributeError, "abc"):
+ Paginator(AttributeErrorContainer(), 10).count
+
+ def test_count_does_not_silence_type_error(self):
+ class TypeErrorContainer:
+ def count(self):
+ raise TypeError("abc")
+
+ with self.assertRaisesMessage(TypeError, "abc"):
+ Paginator(TypeErrorContainer(), 10).count
+
+ def check_indexes(self, params, page_num, indexes):
+ """
+ Helper method that instantiates a Paginator object from the passed
+ params and then checks that the start and end indexes of the passed
+ page_num match those given as a 2-tuple in indexes.
+ """
+ paginator = Paginator(*params)
+ if page_num == "first":
+ page_num = 1
+ elif page_num == "last":
+ page_num = paginator.num_pages
+ page = paginator.page(page_num)
+ start, end = indexes
+ msg = "For %s of page %s, expected %s but got %s. Paginator parameters were: %s"
+ self.assertEqual(
+ start,
+ page.start_index(),
+ msg % ("start index", page_num, start, page.start_index(), params),
+ )
+ self.assertEqual(
+ end,
+ page.end_index(),
+ msg % ("end index", page_num, end, page.end_index(), params),
+ )
+
+ def test_page_indexes(self):
+ """
+ Paginator pages have the correct start and end indexes.
+ """
+ ten = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+ tests = (
+ # Each item is 3-tuple:
+ # First tuple is Paginator parameters - object_list, per_page,
+ # orphans, and allow_empty_first_page.
+ # Second tuple is the start and end indexes of the first page.
+ # Third tuple is the start and end indexes of the last page.
+ # Ten items, varying per_page, no orphans.
+ ((ten, 1, 0, True), (1, 1), (10, 10)),
+ ((ten, 2, 0, True), (1, 2), (9, 10)),
+ ((ten, 3, 0, True), (1, 3), (10, 10)),
+ ((ten, 5, 0, True), (1, 5), (6, 10)),
+ # Ten items, varying per_page, with orphans.
+ ((ten, 1, 1, True), (1, 1), (9, 10)),
+ ((ten, 1, 2, True), (1, 1), (8, 10)),
+ ((ten, 3, 1, True), (1, 3), (7, 10)),
+ ((ten, 3, 2, True), (1, 3), (7, 10)),
+ ((ten, 3, 4, True), (1, 3), (4, 10)),
+ ((ten, 5, 1, True), (1, 5), (6, 10)),
+ ((ten, 5, 2, True), (1, 5), (6, 10)),
+ ((ten, 5, 5, True), (1, 10), (1, 10)),
+ # One item, varying orphans, no empty first page.
+ (([1], 4, 0, False), (1, 1), (1, 1)),
+ (([1], 4, 1, False), (1, 1), (1, 1)),
+ (([1], 4, 2, False), (1, 1), (1, 1)),
+ # One item, varying orphans, allow empty first page.
+ (([1], 4, 0, True), (1, 1), (1, 1)),
+ (([1], 4, 1, True), (1, 1), (1, 1)),
+ (([1], 4, 2, True), (1, 1), (1, 1)),
+ # Zero items, varying orphans, allow empty first page.
+ (([], 4, 0, True), (0, 0), (0, 0)),
+ (([], 4, 1, True), (0, 0), (0, 0)),
+ (([], 4, 2, True), (0, 0), (0, 0)),
+ )
+ for params, first, last in tests:
+ self.check_indexes(params, "first", first)
+ self.check_indexes(params, "last", last)
+
+ # When no items and no empty first page, we should get EmptyPage error.
+ with self.assertRaises(EmptyPage):
+ self.check_indexes(([], 4, 0, False), 1, None)
+ with self.assertRaises(EmptyPage):
+ self.check_indexes(([], 4, 1, False), 1, None)
+ with self.assertRaises(EmptyPage):
+ self.check_indexes(([], 4, 2, False), 1, None)
+
+ def test_page_sequence(self):
+ """
+ A paginator page acts like a standard sequence.
+ """
+ eleven = "abcdefghijk"
+ page2 = Paginator(eleven, per_page=5, orphans=1).page(2)
+ self.assertEqual(len(page2), 6)
+ self.assertIn("k", page2)
+ self.assertNotIn("a", page2)
+ self.assertEqual("".join(page2), "fghijk")
+ self.assertEqual("".join(reversed(page2)), "kjihgf")
+
+ def test_get_page_hook(self):
+ """
+ A Paginator subclass can use the ``_get_page`` hook to
+ return an alternative to the standard Page class.
+ """
+ eleven = "abcdefghijk"
+ paginator = ValidAdjacentNumsPaginator(eleven, per_page=6)
+ page1 = paginator.page(1)
+ page2 = paginator.page(2)
+ self.assertIsNone(page1.previous_page_number())
+ self.assertEqual(page1.next_page_number(), 2)
+ self.assertEqual(page2.previous_page_number(), 1)
+ self.assertIsNone(page2.next_page_number())
+
+ def test_page_range_iterator(self):
+ """
+ Paginator.page_range should be an iterator.
+ """
+ self.assertIsInstance(Paginator([1, 2, 3], 2).page_range, type(range(0)))
+
+ def test_get_page(self):
+ """
+ Paginator.get_page() returns a valid page even with invalid page
+ arguments.
+ """
+ paginator = Paginator([1, 2, 3], 2)
+ page = paginator.get_page(1)
+ self.assertEqual(page.number, 1)
+ self.assertEqual(page.object_list, [1, 2])
+ # An empty page returns the last page.
+ self.assertEqual(paginator.get_page(3).number, 2)
+ # Non-integer page returns the first page.
+ self.assertEqual(paginator.get_page(None).number, 1)
+
+ def test_get_page_empty_object_list(self):
+ """Paginator.get_page() with an empty object_list."""
+ paginator = Paginator([], 2)
+ # An empty page returns the last page.
+ self.assertEqual(paginator.get_page(1).number, 1)
+ self.assertEqual(paginator.get_page(2).number, 1)
+ # Non-integer page returns the first page.
+ self.assertEqual(paginator.get_page(None).number, 1)
+
+ def test_get_page_empty_object_list_and_allow_empty_first_page_false(self):
+ """
+ Paginator.get_page() raises EmptyPage if allow_empty_first_page=False
+ and object_list is empty.
+ """
+ paginator = Paginator([], 2, allow_empty_first_page=False)
+ with self.assertRaises(EmptyPage):
+ paginator.get_page(1)
+
+ def test_paginator_iteration(self):
+ paginator = Paginator([1, 2, 3], 2)
+ page_iterator = iter(paginator)
+ for page, expected in enumerate(([1, 2], [3]), start=1):
+ with self.subTest(page=page):
+ self.assertEqual(expected, list(next(page_iterator)))
+
+ self.assertEqual(
+ [str(page) for page in iter(paginator)],
+ ["", ""],
+ )
+
+ def test_get_elided_page_range(self):
+ # Paginator.validate_number() must be called:
+ paginator = Paginator([1, 2, 3], 2)
+ with unittest.mock.patch.object(paginator, "validate_number") as mock:
+ mock.assert_not_called()
+ list(paginator.get_elided_page_range(2))
+ mock.assert_called_with(2)
+
+ ELLIPSIS = Paginator.ELLIPSIS
+
+ # Range is not elided if not enough pages when using default arguments:
+ paginator = Paginator(range(10 * 100), 100)
+ page_range = paginator.get_elided_page_range(1)
+ self.assertIsInstance(page_range, collections.abc.Generator)
+ self.assertNotIn(ELLIPSIS, page_range)
+ paginator = Paginator(range(10 * 100 + 1), 100)
+ self.assertIsInstance(page_range, collections.abc.Generator)
+ page_range = paginator.get_elided_page_range(1)
+ self.assertIn(ELLIPSIS, page_range)
+
+ # Range should be elided if enough pages when using default arguments:
+ tests = [
+ # on_each_side=3, on_ends=2
+ (1, [1, 2, 3, 4, ELLIPSIS, 49, 50]),
+ (6, [1, 2, 3, 4, 5, 6, 7, 8, 9, ELLIPSIS, 49, 50]),
+ (7, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, ELLIPSIS, 49, 50]),
+ (8, [1, 2, ELLIPSIS, 5, 6, 7, 8, 9, 10, 11, ELLIPSIS, 49, 50]),
+ (43, [1, 2, ELLIPSIS, 40, 41, 42, 43, 44, 45, 46, ELLIPSIS, 49, 50]),
+ (44, [1, 2, ELLIPSIS, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50]),
+ (45, [1, 2, ELLIPSIS, 42, 43, 44, 45, 46, 47, 48, 49, 50]),
+ (50, [1, 2, ELLIPSIS, 47, 48, 49, 50]),
+ ]
+ paginator = Paginator(range(5000), 100)
+ for number, expected in tests:
+ with self.subTest(number=number):
+ page_range = paginator.get_elided_page_range(number)
+ self.assertIsInstance(page_range, collections.abc.Generator)
+ self.assertEqual(list(page_range), expected)
+
+ # Range is not elided if not enough pages when using custom arguments:
+ tests = [
+ (6, 2, 1, 1),
+ (8, 1, 3, 1),
+ (8, 4, 0, 1),
+ (4, 1, 1, 1),
+ # When on_each_side and on_ends are both <= 1 but not both == 1 it
+ # is a special case where the range is not elided until an extra
+ # page is added.
+ (2, 0, 1, 2),
+ (2, 1, 0, 2),
+ (1, 0, 0, 2),
+ ]
+ for pages, on_each_side, on_ends, elided_after in tests:
+ for offset in range(elided_after + 1):
+ with self.subTest(
+ pages=pages,
+ offset=elided_after,
+ on_each_side=on_each_side,
+ on_ends=on_ends,
+ ):
+ paginator = Paginator(range((pages + offset) * 100), 100)
+ page_range = paginator.get_elided_page_range(
+ 1,
+ on_each_side=on_each_side,
+ on_ends=on_ends,
+ )
+ self.assertIsInstance(page_range, collections.abc.Generator)
+ if offset < elided_after:
+ self.assertNotIn(ELLIPSIS, page_range)
+ else:
+ self.assertIn(ELLIPSIS, page_range)
+
+ # Range should be elided if enough pages when using custom arguments:
+ tests = [
+ # on_each_side=2, on_ends=1
+ (1, 2, 1, [1, 2, 3, ELLIPSIS, 50]),
+ (4, 2, 1, [1, 2, 3, 4, 5, 6, ELLIPSIS, 50]),
+ (5, 2, 1, [1, 2, 3, 4, 5, 6, 7, ELLIPSIS, 50]),
+ (6, 2, 1, [1, ELLIPSIS, 4, 5, 6, 7, 8, ELLIPSIS, 50]),
+ (45, 2, 1, [1, ELLIPSIS, 43, 44, 45, 46, 47, ELLIPSIS, 50]),
+ (46, 2, 1, [1, ELLIPSIS, 44, 45, 46, 47, 48, 49, 50]),
+ (47, 2, 1, [1, ELLIPSIS, 45, 46, 47, 48, 49, 50]),
+ (50, 2, 1, [1, ELLIPSIS, 48, 49, 50]),
+ # on_each_side=1, on_ends=3
+ (1, 1, 3, [1, 2, ELLIPSIS, 48, 49, 50]),
+ (5, 1, 3, [1, 2, 3, 4, 5, 6, ELLIPSIS, 48, 49, 50]),
+ (6, 1, 3, [1, 2, 3, 4, 5, 6, 7, ELLIPSIS, 48, 49, 50]),
+ (7, 1, 3, [1, 2, 3, ELLIPSIS, 6, 7, 8, ELLIPSIS, 48, 49, 50]),
+ (44, 1, 3, [1, 2, 3, ELLIPSIS, 43, 44, 45, ELLIPSIS, 48, 49, 50]),
+ (45, 1, 3, [1, 2, 3, ELLIPSIS, 44, 45, 46, 47, 48, 49, 50]),
+ (46, 1, 3, [1, 2, 3, ELLIPSIS, 45, 46, 47, 48, 49, 50]),
+ (50, 1, 3, [1, 2, 3, ELLIPSIS, 49, 50]),
+ # on_each_side=4, on_ends=0
+ (1, 4, 0, [1, 2, 3, 4, 5, ELLIPSIS]),
+ (5, 4, 0, [1, 2, 3, 4, 5, 6, 7, 8, 9, ELLIPSIS]),
+ (6, 4, 0, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, ELLIPSIS]),
+ (7, 4, 0, [ELLIPSIS, 3, 4, 5, 6, 7, 8, 9, 10, 11, ELLIPSIS]),
+ (44, 4, 0, [ELLIPSIS, 40, 41, 42, 43, 44, 45, 46, 47, 48, ELLIPSIS]),
+ (45, 4, 0, [ELLIPSIS, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50]),
+ (46, 4, 0, [ELLIPSIS, 42, 43, 44, 45, 46, 47, 48, 49, 50]),
+ (50, 4, 0, [ELLIPSIS, 46, 47, 48, 49, 50]),
+ # on_each_side=0, on_ends=1
+ (1, 0, 1, [1, ELLIPSIS, 50]),
+ (2, 0, 1, [1, 2, ELLIPSIS, 50]),
+ (3, 0, 1, [1, 2, 3, ELLIPSIS, 50]),
+ (4, 0, 1, [1, ELLIPSIS, 4, ELLIPSIS, 50]),
+ (47, 0, 1, [1, ELLIPSIS, 47, ELLIPSIS, 50]),
+ (48, 0, 1, [1, ELLIPSIS, 48, 49, 50]),
+ (49, 0, 1, [1, ELLIPSIS, 49, 50]),
+ (50, 0, 1, [1, ELLIPSIS, 50]),
+ # on_each_side=0, on_ends=0
+ (1, 0, 0, [1, ELLIPSIS]),
+ (2, 0, 0, [1, 2, ELLIPSIS]),
+ (3, 0, 0, [ELLIPSIS, 3, ELLIPSIS]),
+ (48, 0, 0, [ELLIPSIS, 48, ELLIPSIS]),
+ (49, 0, 0, [ELLIPSIS, 49, 50]),
+ (50, 0, 0, [ELLIPSIS, 50]),
+ ]
+ paginator = Paginator(range(5000), 100)
+ for number, on_each_side, on_ends, expected in tests:
+ with self.subTest(
+ number=number, on_each_side=on_each_side, on_ends=on_ends
+ ):
+ page_range = paginator.get_elided_page_range(
+ number,
+ on_each_side=on_each_side,
+ on_ends=on_ends,
+ )
+ self.assertIsInstance(page_range, collections.abc.Generator)
+ self.assertEqual(list(page_range), expected)
+
+
+class ModelPaginationTests(TestCase):
+ """
+ Test pagination with Django model instances
+ """
+
+ @classmethod
+ def setUpTestData(cls):
+ # Prepare a list of objects for pagination.
+ pub_date = datetime(2005, 7, 29)
+ cls.articles = [
+ Article.objects.create(headline=f"Article {x}", pub_date=pub_date)
+ for x in range(1, 10)
+ ]
+
+ def test_first_page(self):
+ paginator = Paginator(Article.objects.order_by("id"), 5)
+ p = paginator.page(1)
+ self.assertEqual("", str(p))
+ self.assertSequenceEqual(p.object_list, self.articles[:5])
+ self.assertTrue(p.has_next())
+ self.assertFalse(p.has_previous())
+ self.assertTrue(p.has_other_pages())
+ self.assertEqual(2, p.next_page_number())
+ with self.assertRaises(InvalidPage):
+ p.previous_page_number()
+ self.assertEqual(1, p.start_index())
+ self.assertEqual(5, p.end_index())
+
+ def test_last_page(self):
+ paginator = Paginator(Article.objects.order_by("id"), 5)
+ p = paginator.page(2)
+ self.assertEqual("", str(p))
+ self.assertSequenceEqual(p.object_list, self.articles[5:])
+ self.assertFalse(p.has_next())
+ self.assertTrue(p.has_previous())
+ self.assertTrue(p.has_other_pages())
+ with self.assertRaises(InvalidPage):
+ p.next_page_number()
+ self.assertEqual(1, p.previous_page_number())
+ self.assertEqual(6, p.start_index())
+ self.assertEqual(9, p.end_index())
+
+ def test_page_getitem(self):
+ """
+ Tests proper behavior of a paginator page __getitem__ (queryset
+ evaluation, slicing, exception raised).
+ """
+ paginator = Paginator(Article.objects.order_by("id"), 5)
+ p = paginator.page(1)
+
+ # object_list queryset is not evaluated by an invalid __getitem__ call.
+ # (this happens from the template engine when using e.g.:
+ # {% page_obj.has_previous %}).
+ self.assertIsNone(p.object_list._result_cache)
+ msg = "Page indices must be integers or slices, not str."
+ with self.assertRaisesMessage(TypeError, msg):
+ p["has_previous"]
+ self.assertIsNone(p.object_list._result_cache)
+ self.assertNotIsInstance(p.object_list, list)
+
+ # Make sure slicing the Page object with numbers and slice objects work.
+ self.assertEqual(p[0], self.articles[0])
+ self.assertSequenceEqual(p[slice(2)], self.articles[:2])
+ # After __getitem__ is called, object_list is a list
+ self.assertIsInstance(p.object_list, list)
+
+ def test_paginating_unordered_queryset_raises_warning(self):
+ msg = (
+ "Pagination may yield inconsistent results with an unordered "
+ "object_list: QuerySet."
+ )
+ with self.assertWarnsMessage(UnorderedObjectListWarning, msg) as cm:
+ Paginator(Article.objects.all(), 5)
+ # The warning points at the Paginator caller (i.e. the stacklevel
+ # is appropriate).
+ self.assertEqual(cm.filename, __file__)
+
+ def test_paginating_empty_queryset_does_not_warn(self):
+ with warnings.catch_warnings(record=True) as recorded:
+ Paginator(Article.objects.none(), 5)
+ self.assertEqual(len(recorded), 0)
+
+ def test_paginating_unordered_object_list_raises_warning(self):
+ """
+ Unordered object list warning with an object that has an ordered
+ attribute but not a model attribute.
+ """
+
+ class ObjectList:
+ ordered = False
+
+ object_list = ObjectList()
+ msg = (
+ "Pagination may yield inconsistent results with an unordered "
+ "object_list: {!r}.".format(object_list)
+ )
+ with self.assertWarnsMessage(UnorderedObjectListWarning, msg):
+ Paginator(object_list, 5)
diff --git a/testbed/django__django/tests/postgres_tests/__init__.py b/testbed/django__django/tests/postgres_tests/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..02f39e39359ed37cb7a6ceb89f33c743d642907e
--- /dev/null
+++ b/testbed/django__django/tests/postgres_tests/__init__.py
@@ -0,0 +1,37 @@
+import unittest
+
+from forms_tests.widget_tests.base import WidgetTest
+
+from django.db import connection
+from django.test import SimpleTestCase, TestCase, modify_settings
+from django.utils.functional import cached_property
+
+
+@unittest.skipUnless(connection.vendor == "postgresql", "PostgreSQL specific tests")
+# To register type handlers and locate the widget's template.
+@modify_settings(INSTALLED_APPS={"append": "django.contrib.postgres"})
+class PostgreSQLSimpleTestCase(SimpleTestCase):
+ pass
+
+
+@unittest.skipUnless(connection.vendor == "postgresql", "PostgreSQL specific tests")
+# To register type handlers and locate the widget's template.
+@modify_settings(INSTALLED_APPS={"append": "django.contrib.postgres"})
+class PostgreSQLTestCase(TestCase):
+ @cached_property
+ def default_text_search_config(self):
+ with connection.cursor() as cursor:
+ cursor.execute("SHOW default_text_search_config")
+ row = cursor.fetchone()
+ return row[0] if row else None
+
+ def check_default_text_search_config(self):
+ if self.default_text_search_config != "pg_catalog.english":
+ self.skipTest("The default text search config is not 'english'.")
+
+
+@unittest.skipUnless(connection.vendor == "postgresql", "PostgreSQL specific tests")
+# To locate the widget's template.
+@modify_settings(INSTALLED_APPS={"append": "django.contrib.postgres"})
+class PostgreSQLWidgetTestCase(WidgetTest, PostgreSQLSimpleTestCase):
+ pass
diff --git a/testbed/django__django/tests/postgres_tests/array_default_migrations/0001_initial.py b/testbed/django__django/tests/postgres_tests/array_default_migrations/0001_initial.py
new file mode 100644
index 0000000000000000000000000000000000000000..5c6fa7e189003ad73432854b8f927288e5a5adfb
--- /dev/null
+++ b/testbed/django__django/tests/postgres_tests/array_default_migrations/0001_initial.py
@@ -0,0 +1,31 @@
+import django.contrib.postgres.fields
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+ dependencies = []
+
+ operations = [
+ migrations.CreateModel(
+ name="IntegerArrayDefaultModel",
+ fields=[
+ (
+ "id",
+ models.AutoField(
+ verbose_name="ID",
+ serialize=False,
+ auto_created=True,
+ primary_key=True,
+ ),
+ ),
+ (
+ "field",
+ django.contrib.postgres.fields.ArrayField(
+ models.IntegerField(), size=None
+ ),
+ ),
+ ],
+ options={},
+ bases=(models.Model,),
+ ),
+ ]
diff --git a/testbed/django__django/tests/postgres_tests/array_default_migrations/0002_integerarraymodel_field_2.py b/testbed/django__django/tests/postgres_tests/array_default_migrations/0002_integerarraymodel_field_2.py
new file mode 100644
index 0000000000000000000000000000000000000000..ab1f06b5deb58d39a7fd1bb31eb507b1060119d3
--- /dev/null
+++ b/testbed/django__django/tests/postgres_tests/array_default_migrations/0002_integerarraymodel_field_2.py
@@ -0,0 +1,19 @@
+import django.contrib.postgres.fields
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+ dependencies = [
+ ("postgres_tests", "0001_initial"),
+ ]
+
+ operations = [
+ migrations.AddField(
+ model_name="integerarraydefaultmodel",
+ name="field_2",
+ field=django.contrib.postgres.fields.ArrayField(
+ models.IntegerField(), default=[], size=None
+ ),
+ preserve_default=False,
+ ),
+ ]
diff --git a/testbed/django__django/tests/postgres_tests/array_default_migrations/__init__.py b/testbed/django__django/tests/postgres_tests/array_default_migrations/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testbed/django__django/tests/postgres_tests/array_index_migrations/0001_initial.py b/testbed/django__django/tests/postgres_tests/array_index_migrations/0001_initial.py
new file mode 100644
index 0000000000000000000000000000000000000000..d08243b67e1e747a276dfee97412494f067a7844
--- /dev/null
+++ b/testbed/django__django/tests/postgres_tests/array_index_migrations/0001_initial.py
@@ -0,0 +1,38 @@
+import django.contrib.postgres.fields
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+ dependencies = []
+
+ operations = [
+ migrations.CreateModel(
+ name="CharTextArrayIndexModel",
+ fields=[
+ (
+ "id",
+ models.AutoField(
+ verbose_name="ID",
+ serialize=False,
+ auto_created=True,
+ primary_key=True,
+ ),
+ ),
+ (
+ "char",
+ django.contrib.postgres.fields.ArrayField(
+ models.CharField(max_length=10), db_index=True, size=100
+ ),
+ ),
+ ("char2", models.CharField(max_length=11, db_index=True)),
+ (
+ "text",
+ django.contrib.postgres.fields.ArrayField(
+ models.TextField(), db_index=True
+ ),
+ ),
+ ],
+ options={},
+ bases=(models.Model,),
+ ),
+ ]
diff --git a/testbed/django__django/tests/postgres_tests/array_index_migrations/__init__.py b/testbed/django__django/tests/postgres_tests/array_index_migrations/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testbed/django__django/tests/postgres_tests/fields.py b/testbed/django__django/tests/postgres_tests/fields.py
new file mode 100644
index 0000000000000000000000000000000000000000..1565b5ed439e9e34689a2129d67a0b96be27ce68
--- /dev/null
+++ b/testbed/django__django/tests/postgres_tests/fields.py
@@ -0,0 +1,64 @@
+"""
+Indirection layer for PostgreSQL-specific fields, so the tests don't fail when
+run with a backend other than PostgreSQL.
+"""
+import enum
+
+from django.db import models
+
+try:
+ from django.contrib.postgres.fields import CICharField # RemovedInDjango51Warning.
+ from django.contrib.postgres.fields import CIEmailField # RemovedInDjango51Warning.
+ from django.contrib.postgres.fields import CITextField # RemovedInDjango51Warning.
+ from django.contrib.postgres.fields import (
+ ArrayField,
+ BigIntegerRangeField,
+ DateRangeField,
+ DateTimeRangeField,
+ DecimalRangeField,
+ HStoreField,
+ IntegerRangeField,
+ )
+ from django.contrib.postgres.search import SearchVector, SearchVectorField
+except ImportError:
+
+ class DummyArrayField(models.Field):
+ def __init__(self, base_field, size=None, **kwargs):
+ super().__init__(**kwargs)
+
+ def deconstruct(self):
+ name, path, args, kwargs = super().deconstruct()
+ kwargs.update(
+ {
+ "base_field": "",
+ "size": 1,
+ }
+ )
+ return name, path, args, kwargs
+
+ class DummyContinuousRangeField(models.Field):
+ def __init__(self, *args, default_bounds="[)", **kwargs):
+ super().__init__(**kwargs)
+
+ def deconstruct(self):
+ name, path, args, kwargs = super().deconstruct()
+ kwargs["default_bounds"] = "[)"
+ return name, path, args, kwargs
+
+ ArrayField = DummyArrayField
+ BigIntegerRangeField = models.Field
+ CICharField = models.Field # RemovedInDjango51Warning.
+ CIEmailField = models.Field # RemovedInDjango51Warning.
+ CITextField = models.Field # RemovedInDjango51Warning.
+ DateRangeField = models.Field
+ DateTimeRangeField = DummyContinuousRangeField
+ DecimalRangeField = DummyContinuousRangeField
+ HStoreField = models.Field
+ IntegerRangeField = models.Field
+ SearchVector = models.Expression
+ SearchVectorField = models.Field
+
+
+class EnumField(models.CharField):
+ def get_prep_value(self, value):
+ return value.value if isinstance(value, enum.Enum) else value
diff --git a/testbed/django__django/tests/postgres_tests/integration_settings.py b/testbed/django__django/tests/postgres_tests/integration_settings.py
new file mode 100644
index 0000000000000000000000000000000000000000..7e2ea9c8d02212880fd9f0244b80eb0fb6ac4c8b
--- /dev/null
+++ b/testbed/django__django/tests/postgres_tests/integration_settings.py
@@ -0,0 +1,5 @@
+SECRET_KEY = "abcdefg"
+
+INSTALLED_APPS = [
+ "django.contrib.postgres",
+]
diff --git a/testbed/django__django/tests/postgres_tests/migrations/0001_setup_extensions.py b/testbed/django__django/tests/postgres_tests/migrations/0001_setup_extensions.py
new file mode 100644
index 0000000000000000000000000000000000000000..8045610aefb1253f838ce12467d741fc4e3126ba
--- /dev/null
+++ b/testbed/django__django/tests/postgres_tests/migrations/0001_setup_extensions.py
@@ -0,0 +1,47 @@
+from unittest import mock
+
+from django.db import connection, migrations
+
+try:
+ from django.contrib.postgres.operations import (
+ BloomExtension,
+ BtreeGinExtension,
+ BtreeGistExtension,
+ CITextExtension,
+ CreateExtension,
+ CryptoExtension,
+ HStoreExtension,
+ TrigramExtension,
+ UnaccentExtension,
+ )
+except ImportError:
+ BloomExtension = mock.Mock()
+ BtreeGinExtension = mock.Mock()
+ BtreeGistExtension = mock.Mock()
+ CITextExtension = mock.Mock()
+ CreateExtension = mock.Mock()
+ HStoreExtension = mock.Mock()
+ TrigramExtension = mock.Mock()
+ UnaccentExtension = mock.Mock()
+ needs_crypto_extension = False
+else:
+ needs_crypto_extension = (
+ connection.vendor == "postgresql" and not connection.features.is_postgresql_13
+ )
+
+
+class Migration(migrations.Migration):
+ operations = [
+ BloomExtension(),
+ BtreeGinExtension(),
+ BtreeGistExtension(),
+ CITextExtension(),
+ # Ensure CreateExtension quotes extension names by creating one with a
+ # dash in its name.
+ CreateExtension("uuid-ossp"),
+ # CryptoExtension is required for RandomUUID() on PostgreSQL < 13.
+ CryptoExtension() if needs_crypto_extension else mock.Mock(),
+ HStoreExtension(),
+ TrigramExtension(),
+ UnaccentExtension(),
+ ]
diff --git a/testbed/django__django/tests/postgres_tests/migrations/0002_create_test_models.py b/testbed/django__django/tests/postgres_tests/migrations/0002_create_test_models.py
new file mode 100644
index 0000000000000000000000000000000000000000..011a0d729b896f462d1a57e14eb5119db727ebb1
--- /dev/null
+++ b/testbed/django__django/tests/postgres_tests/migrations/0002_create_test_models.py
@@ -0,0 +1,571 @@
+from django.db import migrations, models
+
+from ..fields import (
+ ArrayField,
+ BigIntegerRangeField,
+ CICharField,
+ CIEmailField,
+ CITextField,
+ DateRangeField,
+ DateTimeRangeField,
+ DecimalRangeField,
+ EnumField,
+ HStoreField,
+ IntegerRangeField,
+ SearchVectorField,
+)
+from ..models import TagField
+
+
+class Migration(migrations.Migration):
+ dependencies = [
+ ("postgres_tests", "0001_setup_extensions"),
+ ]
+
+ operations = [
+ migrations.CreateModel(
+ name="CharArrayModel",
+ fields=[
+ (
+ "id",
+ models.AutoField(
+ verbose_name="ID",
+ serialize=False,
+ auto_created=True,
+ primary_key=True,
+ ),
+ ),
+ ("field", ArrayField(models.CharField(max_length=10), size=None)),
+ ],
+ options={
+ "required_db_vendor": "postgresql",
+ },
+ bases=(models.Model,),
+ ),
+ migrations.CreateModel(
+ name="DateTimeArrayModel",
+ fields=[
+ (
+ "id",
+ models.AutoField(
+ verbose_name="ID",
+ serialize=False,
+ auto_created=True,
+ primary_key=True,
+ ),
+ ),
+ ("datetimes", ArrayField(models.DateTimeField(), size=None)),
+ ("dates", ArrayField(models.DateField(), size=None)),
+ ("times", ArrayField(models.TimeField(), size=None)),
+ ],
+ options={
+ "required_db_vendor": "postgresql",
+ },
+ bases=(models.Model,),
+ ),
+ migrations.CreateModel(
+ name="HStoreModel",
+ fields=[
+ (
+ "id",
+ models.AutoField(
+ verbose_name="ID",
+ serialize=False,
+ auto_created=True,
+ primary_key=True,
+ ),
+ ),
+ ("field", HStoreField(blank=True, null=True)),
+ ("array_field", ArrayField(HStoreField(), null=True)),
+ ],
+ options={
+ "required_db_vendor": "postgresql",
+ },
+ bases=(models.Model,),
+ ),
+ migrations.CreateModel(
+ name="OtherTypesArrayModel",
+ fields=[
+ (
+ "id",
+ models.AutoField(
+ verbose_name="ID",
+ serialize=False,
+ auto_created=True,
+ primary_key=True,
+ ),
+ ),
+ (
+ "ips",
+ ArrayField(models.GenericIPAddressField(), size=None, default=list),
+ ),
+ ("uuids", ArrayField(models.UUIDField(), size=None, default=list)),
+ (
+ "decimals",
+ ArrayField(
+ models.DecimalField(max_digits=5, decimal_places=2),
+ size=None,
+ default=list,
+ ),
+ ),
+ ("tags", ArrayField(TagField(), blank=True, null=True, size=None)),
+ (
+ "json",
+ ArrayField(models.JSONField(default=dict), default=list, size=None),
+ ),
+ ("int_ranges", ArrayField(IntegerRangeField(), null=True, blank=True)),
+ (
+ "bigint_ranges",
+ ArrayField(BigIntegerRangeField(), null=True, blank=True),
+ ),
+ ],
+ options={
+ "required_db_vendor": "postgresql",
+ },
+ bases=(models.Model,),
+ ),
+ migrations.CreateModel(
+ name="IntegerArrayModel",
+ fields=[
+ (
+ "id",
+ models.AutoField(
+ verbose_name="ID",
+ serialize=False,
+ auto_created=True,
+ primary_key=True,
+ ),
+ ),
+ (
+ "field",
+ ArrayField(
+ models.IntegerField(), blank=True, default=list, size=None
+ ),
+ ),
+ ],
+ options={
+ "required_db_vendor": "postgresql",
+ },
+ bases=(models.Model,),
+ ),
+ migrations.CreateModel(
+ name="NestedIntegerArrayModel",
+ fields=[
+ (
+ "id",
+ models.AutoField(
+ verbose_name="ID",
+ serialize=False,
+ auto_created=True,
+ primary_key=True,
+ ),
+ ),
+ (
+ "field",
+ ArrayField(ArrayField(models.IntegerField(), size=None), size=None),
+ ),
+ ],
+ options={
+ "required_db_vendor": "postgresql",
+ },
+ bases=(models.Model,),
+ ),
+ migrations.CreateModel(
+ name="NullableIntegerArrayModel",
+ fields=[
+ (
+ "id",
+ models.AutoField(
+ verbose_name="ID",
+ serialize=False,
+ auto_created=True,
+ primary_key=True,
+ ),
+ ),
+ (
+ "field",
+ ArrayField(models.IntegerField(), size=None, null=True, blank=True),
+ ),
+ (
+ "field_nested",
+ ArrayField(
+ ArrayField(models.IntegerField(null=True), size=None),
+ size=None,
+ null=True,
+ ),
+ ),
+ ("order", models.IntegerField(null=True)),
+ ],
+ options={
+ "required_db_vendor": "postgresql",
+ },
+ bases=(models.Model,),
+ ),
+ migrations.CreateModel(
+ name="CharFieldModel",
+ fields=[
+ (
+ "id",
+ models.AutoField(
+ verbose_name="ID",
+ serialize=False,
+ auto_created=True,
+ primary_key=True,
+ ),
+ ),
+ ("field", models.CharField(max_length=64)),
+ ],
+ options=None,
+ bases=None,
+ ),
+ migrations.CreateModel(
+ name="TextFieldModel",
+ fields=[
+ (
+ "id",
+ models.AutoField(
+ verbose_name="ID",
+ serialize=False,
+ auto_created=True,
+ primary_key=True,
+ ),
+ ),
+ ("field", models.TextField()),
+ ],
+ options=None,
+ bases=None,
+ ),
+ migrations.CreateModel(
+ name="SmallAutoFieldModel",
+ fields=[
+ (
+ "id",
+ models.SmallAutoField(serialize=False, primary_key=True),
+ ),
+ ],
+ options=None,
+ ),
+ migrations.CreateModel(
+ name="BigAutoFieldModel",
+ fields=[
+ (
+ "id",
+ models.BigAutoField(serialize=False, primary_key=True),
+ ),
+ ],
+ options=None,
+ ),
+ migrations.CreateModel(
+ name="Scene",
+ fields=[
+ (
+ "id",
+ models.AutoField(
+ verbose_name="ID",
+ serialize=False,
+ auto_created=True,
+ primary_key=True,
+ ),
+ ),
+ ("scene", models.TextField()),
+ ("setting", models.CharField(max_length=255)),
+ ],
+ options=None,
+ bases=None,
+ ),
+ migrations.CreateModel(
+ name="Character",
+ fields=[
+ (
+ "id",
+ models.AutoField(
+ verbose_name="ID",
+ serialize=False,
+ auto_created=True,
+ primary_key=True,
+ ),
+ ),
+ ("name", models.CharField(max_length=255)),
+ ],
+ options=None,
+ bases=None,
+ ),
+ # RemovedInDjango51Warning.
+ migrations.CreateModel(
+ name="CITestModel",
+ fields=[
+ (
+ "name",
+ CICharField(primary_key=True, serialize=False, max_length=255),
+ ),
+ ("email", CIEmailField()),
+ ("description", CITextField()),
+ ("array_field", ArrayField(CITextField(), null=True)),
+ ],
+ options={
+ "required_db_vendor": "postgresql",
+ },
+ bases=None,
+ ),
+ migrations.CreateModel(
+ name="Line",
+ fields=[
+ (
+ "id",
+ models.AutoField(
+ verbose_name="ID",
+ serialize=False,
+ auto_created=True,
+ primary_key=True,
+ ),
+ ),
+ (
+ "scene",
+ models.ForeignKey("postgres_tests.Scene", on_delete=models.CASCADE),
+ ),
+ (
+ "character",
+ models.ForeignKey(
+ "postgres_tests.Character", on_delete=models.CASCADE
+ ),
+ ),
+ ("dialogue", models.TextField(blank=True, null=True)),
+ ("dialogue_search_vector", SearchVectorField(blank=True, null=True)),
+ (
+ "dialogue_config",
+ models.CharField(max_length=100, blank=True, null=True),
+ ),
+ ],
+ options={
+ "required_db_vendor": "postgresql",
+ },
+ bases=None,
+ ),
+ migrations.CreateModel(
+ name="LineSavedSearch",
+ fields=[
+ (
+ "id",
+ models.AutoField(
+ verbose_name="ID",
+ serialize=False,
+ auto_created=True,
+ primary_key=True,
+ ),
+ ),
+ (
+ "line",
+ models.ForeignKey("postgres_tests.Line", on_delete=models.CASCADE),
+ ),
+ ("query", models.CharField(max_length=100)),
+ ],
+ options={
+ "required_db_vendor": "postgresql",
+ },
+ ),
+ migrations.CreateModel(
+ name="AggregateTestModel",
+ fields=[
+ (
+ "id",
+ models.AutoField(
+ verbose_name="ID",
+ serialize=False,
+ auto_created=True,
+ primary_key=True,
+ ),
+ ),
+ ("boolean_field", models.BooleanField(null=True)),
+ ("char_field", models.CharField(max_length=30, blank=True)),
+ ("text_field", models.TextField(blank=True)),
+ ("integer_field", models.IntegerField(null=True)),
+ ("json_field", models.JSONField(null=True)),
+ ],
+ options={
+ "required_db_vendor": "postgresql",
+ },
+ ),
+ migrations.CreateModel(
+ name="StatTestModel",
+ fields=[
+ (
+ "id",
+ models.AutoField(
+ verbose_name="ID",
+ serialize=False,
+ auto_created=True,
+ primary_key=True,
+ ),
+ ),
+ ("int1", models.IntegerField()),
+ ("int2", models.IntegerField()),
+ (
+ "related_field",
+ models.ForeignKey(
+ "postgres_tests.AggregateTestModel",
+ models.SET_NULL,
+ null=True,
+ ),
+ ),
+ ],
+ options={
+ "required_db_vendor": "postgresql",
+ },
+ ),
+ migrations.CreateModel(
+ name="NowTestModel",
+ fields=[
+ (
+ "id",
+ models.AutoField(
+ verbose_name="ID",
+ serialize=False,
+ auto_created=True,
+ primary_key=True,
+ ),
+ ),
+ ("when", models.DateTimeField(null=True, default=None)),
+ ],
+ ),
+ migrations.CreateModel(
+ name="UUIDTestModel",
+ fields=[
+ (
+ "id",
+ models.AutoField(
+ verbose_name="ID",
+ serialize=False,
+ auto_created=True,
+ primary_key=True,
+ ),
+ ),
+ ("uuid", models.UUIDField(default=None, null=True)),
+ ],
+ ),
+ migrations.CreateModel(
+ name="RangesModel",
+ fields=[
+ (
+ "id",
+ models.AutoField(
+ verbose_name="ID",
+ serialize=False,
+ auto_created=True,
+ primary_key=True,
+ ),
+ ),
+ ("ints", IntegerRangeField(null=True, blank=True)),
+ ("bigints", BigIntegerRangeField(null=True, blank=True)),
+ ("decimals", DecimalRangeField(null=True, blank=True)),
+ ("timestamps", DateTimeRangeField(null=True, blank=True)),
+ ("timestamps_inner", DateTimeRangeField(null=True, blank=True)),
+ (
+ "timestamps_closed_bounds",
+ DateTimeRangeField(null=True, blank=True, default_bounds="[]"),
+ ),
+ ("dates", DateRangeField(null=True, blank=True)),
+ ("dates_inner", DateRangeField(null=True, blank=True)),
+ ],
+ options={"required_db_vendor": "postgresql"},
+ bases=(models.Model,),
+ ),
+ migrations.CreateModel(
+ name="RangeLookupsModel",
+ fields=[
+ (
+ "id",
+ models.AutoField(
+ verbose_name="ID",
+ serialize=False,
+ auto_created=True,
+ primary_key=True,
+ ),
+ ),
+ (
+ "parent",
+ models.ForeignKey(
+ "postgres_tests.RangesModel",
+ models.SET_NULL,
+ blank=True,
+ null=True,
+ ),
+ ),
+ ("integer", models.IntegerField(blank=True, null=True)),
+ ("big_integer", models.BigIntegerField(blank=True, null=True)),
+ ("float", models.FloatField(blank=True, null=True)),
+ ("timestamp", models.DateTimeField(blank=True, null=True)),
+ ("date", models.DateField(blank=True, null=True)),
+ ("small_integer", models.SmallIntegerField(blank=True, null=True)),
+ (
+ "decimal_field",
+ models.DecimalField(
+ max_digits=5, decimal_places=2, blank=True, null=True
+ ),
+ ),
+ ],
+ options={
+ "required_db_vendor": "postgresql",
+ },
+ bases=(models.Model,),
+ ),
+ migrations.CreateModel(
+ name="ArrayEnumModel",
+ fields=[
+ (
+ "id",
+ models.AutoField(
+ verbose_name="ID",
+ serialize=False,
+ auto_created=True,
+ primary_key=True,
+ ),
+ ),
+ (
+ "array_of_enums",
+ ArrayField(EnumField(max_length=20), size=None),
+ ),
+ ],
+ options={
+ "required_db_vendor": "postgresql",
+ },
+ bases=(models.Model,),
+ ),
+ migrations.CreateModel(
+ name="Room",
+ fields=[
+ (
+ "id",
+ models.AutoField(
+ verbose_name="ID",
+ serialize=False,
+ auto_created=True,
+ primary_key=True,
+ ),
+ ),
+ ("number", models.IntegerField(unique=True)),
+ ],
+ ),
+ migrations.CreateModel(
+ name="HotelReservation",
+ fields=[
+ (
+ "id",
+ models.AutoField(
+ verbose_name="ID",
+ serialize=False,
+ auto_created=True,
+ primary_key=True,
+ ),
+ ),
+ ("room", models.ForeignKey("postgres_tests.Room", models.CASCADE)),
+ ("datespan", DateRangeField()),
+ ("start", models.DateTimeField()),
+ ("end", models.DateTimeField()),
+ ("cancelled", models.BooleanField(default=False)),
+ ("requirements", models.JSONField(blank=True, null=True)),
+ ],
+ options={
+ "required_db_vendor": "postgresql",
+ },
+ ),
+ ]
diff --git a/testbed/django__django/tests/postgres_tests/migrations/__init__.py b/testbed/django__django/tests/postgres_tests/migrations/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testbed/django__django/tests/postgres_tests/models.py b/testbed/django__django/tests/postgres_tests/models.py
new file mode 100644
index 0000000000000000000000000000000000000000..05f2732fb8b534e43bb3fa3005562f97d920eee7
--- /dev/null
+++ b/testbed/django__django/tests/postgres_tests/models.py
@@ -0,0 +1,216 @@
+from django.db import models
+
+from .fields import (
+ ArrayField,
+ BigIntegerRangeField,
+ CICharField,
+ CIEmailField,
+ CITextField,
+ DateRangeField,
+ DateTimeRangeField,
+ DecimalRangeField,
+ EnumField,
+ HStoreField,
+ IntegerRangeField,
+ SearchVectorField,
+)
+
+
+class Tag:
+ def __init__(self, tag_id):
+ self.tag_id = tag_id
+
+ def __eq__(self, other):
+ return isinstance(other, Tag) and self.tag_id == other.tag_id
+
+
+class TagField(models.SmallIntegerField):
+ def from_db_value(self, value, expression, connection):
+ if value is None:
+ return value
+ return Tag(int(value))
+
+ def to_python(self, value):
+ if isinstance(value, Tag):
+ return value
+ if value is None:
+ return value
+ return Tag(int(value))
+
+ def get_prep_value(self, value):
+ return value.tag_id
+
+
+class PostgreSQLModel(models.Model):
+ class Meta:
+ abstract = True
+ required_db_vendor = "postgresql"
+
+
+class IntegerArrayModel(PostgreSQLModel):
+ field = ArrayField(models.IntegerField(), default=list, blank=True)
+
+
+class NullableIntegerArrayModel(PostgreSQLModel):
+ field = ArrayField(models.IntegerField(), blank=True, null=True)
+ field_nested = ArrayField(ArrayField(models.IntegerField(null=True)), null=True)
+ order = models.IntegerField(null=True)
+
+
+class CharArrayModel(PostgreSQLModel):
+ field = ArrayField(models.CharField(max_length=10))
+
+
+class DateTimeArrayModel(PostgreSQLModel):
+ datetimes = ArrayField(models.DateTimeField())
+ dates = ArrayField(models.DateField())
+ times = ArrayField(models.TimeField())
+
+
+class NestedIntegerArrayModel(PostgreSQLModel):
+ field = ArrayField(ArrayField(models.IntegerField()))
+
+
+class OtherTypesArrayModel(PostgreSQLModel):
+ ips = ArrayField(models.GenericIPAddressField(), default=list)
+ uuids = ArrayField(models.UUIDField(), default=list)
+ decimals = ArrayField(
+ models.DecimalField(max_digits=5, decimal_places=2), default=list
+ )
+ tags = ArrayField(TagField(), blank=True, null=True)
+ json = ArrayField(models.JSONField(default=dict), default=list)
+ int_ranges = ArrayField(IntegerRangeField(), blank=True, null=True)
+ bigint_ranges = ArrayField(BigIntegerRangeField(), blank=True, null=True)
+
+
+class HStoreModel(PostgreSQLModel):
+ field = HStoreField(blank=True, null=True)
+ array_field = ArrayField(HStoreField(), null=True)
+
+
+class ArrayEnumModel(PostgreSQLModel):
+ array_of_enums = ArrayField(EnumField(max_length=20))
+
+
+class CharFieldModel(models.Model):
+ field = models.CharField(max_length=64)
+
+
+class TextFieldModel(models.Model):
+ field = models.TextField()
+
+
+class SmallAutoFieldModel(models.Model):
+ id = models.SmallAutoField(primary_key=True)
+
+
+class BigAutoFieldModel(models.Model):
+ id = models.BigAutoField(primary_key=True)
+
+
+# Scene/Character/Line models are used to test full text search. They're
+# populated with content from Monty Python and the Holy Grail.
+class Scene(models.Model):
+ scene = models.TextField()
+ setting = models.CharField(max_length=255)
+
+
+class Character(models.Model):
+ name = models.CharField(max_length=255)
+
+
+# RemovedInDjango51Warning.
+class CITestModel(PostgreSQLModel):
+ name = CICharField(primary_key=True, max_length=255)
+ email = CIEmailField()
+ description = CITextField()
+ array_field = ArrayField(CITextField(), null=True)
+
+
+class Line(PostgreSQLModel):
+ scene = models.ForeignKey("Scene", models.CASCADE)
+ character = models.ForeignKey("Character", models.CASCADE)
+ dialogue = models.TextField(blank=True, null=True)
+ dialogue_search_vector = SearchVectorField(blank=True, null=True)
+ dialogue_config = models.CharField(max_length=100, blank=True, null=True)
+
+
+class LineSavedSearch(PostgreSQLModel):
+ line = models.ForeignKey("Line", models.CASCADE)
+ query = models.CharField(max_length=100)
+
+
+class RangesModel(PostgreSQLModel):
+ ints = IntegerRangeField(blank=True, null=True)
+ bigints = BigIntegerRangeField(blank=True, null=True)
+ decimals = DecimalRangeField(blank=True, null=True)
+ timestamps = DateTimeRangeField(blank=True, null=True)
+ timestamps_inner = DateTimeRangeField(blank=True, null=True)
+ timestamps_closed_bounds = DateTimeRangeField(
+ blank=True,
+ null=True,
+ default_bounds="[]",
+ )
+ dates = DateRangeField(blank=True, null=True)
+ dates_inner = DateRangeField(blank=True, null=True)
+
+
+class RangeLookupsModel(PostgreSQLModel):
+ parent = models.ForeignKey(RangesModel, models.SET_NULL, blank=True, null=True)
+ integer = models.IntegerField(blank=True, null=True)
+ big_integer = models.BigIntegerField(blank=True, null=True)
+ float = models.FloatField(blank=True, null=True)
+ timestamp = models.DateTimeField(blank=True, null=True)
+ date = models.DateField(blank=True, null=True)
+ small_integer = models.SmallIntegerField(blank=True, null=True)
+ decimal_field = models.DecimalField(
+ max_digits=5, decimal_places=2, blank=True, null=True
+ )
+
+
+class ArrayFieldSubclass(ArrayField):
+ def __init__(self, *args, **kwargs):
+ super().__init__(models.IntegerField())
+
+
+class AggregateTestModel(PostgreSQLModel):
+ """
+ To test postgres-specific general aggregation functions
+ """
+
+ char_field = models.CharField(max_length=30, blank=True)
+ text_field = models.TextField(blank=True)
+ integer_field = models.IntegerField(null=True)
+ boolean_field = models.BooleanField(null=True)
+ json_field = models.JSONField(null=True)
+
+
+class StatTestModel(PostgreSQLModel):
+ """
+ To test postgres-specific aggregation functions for statistics
+ """
+
+ int1 = models.IntegerField()
+ int2 = models.IntegerField()
+ related_field = models.ForeignKey(AggregateTestModel, models.SET_NULL, null=True)
+
+
+class NowTestModel(models.Model):
+ when = models.DateTimeField(null=True, default=None)
+
+
+class UUIDTestModel(models.Model):
+ uuid = models.UUIDField(default=None, null=True)
+
+
+class Room(models.Model):
+ number = models.IntegerField(unique=True)
+
+
+class HotelReservation(PostgreSQLModel):
+ room = models.ForeignKey("Room", on_delete=models.CASCADE)
+ datespan = DateRangeField()
+ start = models.DateTimeField()
+ end = models.DateTimeField()
+ cancelled = models.BooleanField(default=False)
+ requirements = models.JSONField(blank=True, null=True)
diff --git a/testbed/django__django/tests/postgres_tests/test_aggregates.py b/testbed/django__django/tests/postgres_tests/test_aggregates.py
new file mode 100644
index 0000000000000000000000000000000000000000..bb694dae6386e7844856c2b2cfd5a5416a6c3d88
--- /dev/null
+++ b/testbed/django__django/tests/postgres_tests/test_aggregates.py
@@ -0,0 +1,963 @@
+from django.db import connection, transaction
+from django.db.models import (
+ CharField,
+ F,
+ Func,
+ IntegerField,
+ JSONField,
+ OuterRef,
+ Q,
+ Subquery,
+ Value,
+ Window,
+)
+from django.db.models.fields.json import KeyTextTransform, KeyTransform
+from django.db.models.functions import Cast, Concat, Substr
+from django.test import skipUnlessDBFeature
+from django.test.utils import Approximate, ignore_warnings
+from django.utils import timezone
+from django.utils.deprecation import RemovedInDjango51Warning
+
+from . import PostgreSQLTestCase
+from .models import AggregateTestModel, HotelReservation, Room, StatTestModel
+
+try:
+ from django.contrib.postgres.aggregates import (
+ ArrayAgg,
+ BitAnd,
+ BitOr,
+ BitXor,
+ BoolAnd,
+ BoolOr,
+ Corr,
+ CovarPop,
+ JSONBAgg,
+ RegrAvgX,
+ RegrAvgY,
+ RegrCount,
+ RegrIntercept,
+ RegrR2,
+ RegrSlope,
+ RegrSXX,
+ RegrSXY,
+ RegrSYY,
+ StatAggregate,
+ StringAgg,
+ )
+ from django.contrib.postgres.fields import ArrayField
+except ImportError:
+ pass # psycopg2 is not installed
+
+
+class TestGeneralAggregate(PostgreSQLTestCase):
+ @classmethod
+ def setUpTestData(cls):
+ cls.aggs = AggregateTestModel.objects.bulk_create(
+ [
+ AggregateTestModel(
+ boolean_field=True,
+ char_field="Foo1",
+ text_field="Text1",
+ integer_field=0,
+ ),
+ AggregateTestModel(
+ boolean_field=False,
+ char_field="Foo2",
+ text_field="Text2",
+ integer_field=1,
+ json_field={"lang": "pl"},
+ ),
+ AggregateTestModel(
+ boolean_field=False,
+ char_field="Foo4",
+ text_field="Text4",
+ integer_field=2,
+ json_field={"lang": "en"},
+ ),
+ AggregateTestModel(
+ boolean_field=True,
+ char_field="Foo3",
+ text_field="Text3",
+ integer_field=0,
+ json_field={"breed": "collie"},
+ ),
+ ]
+ )
+
+ def test_empty_result_set(self):
+ AggregateTestModel.objects.all().delete()
+ tests = [
+ ArrayAgg("char_field"),
+ ArrayAgg("integer_field"),
+ ArrayAgg("boolean_field"),
+ BitAnd("integer_field"),
+ BitOr("integer_field"),
+ BoolAnd("boolean_field"),
+ BoolOr("boolean_field"),
+ JSONBAgg("integer_field"),
+ StringAgg("char_field", delimiter=";"),
+ ]
+ if connection.features.has_bit_xor:
+ tests.append(BitXor("integer_field"))
+ for aggregation in tests:
+ with self.subTest(aggregation=aggregation):
+ # Empty result with non-execution optimization.
+ with self.assertNumQueries(0):
+ values = AggregateTestModel.objects.none().aggregate(
+ aggregation=aggregation,
+ )
+ self.assertEqual(values, {"aggregation": None})
+ # Empty result when query must be executed.
+ with self.assertNumQueries(1):
+ values = AggregateTestModel.objects.aggregate(
+ aggregation=aggregation,
+ )
+ self.assertEqual(values, {"aggregation": None})
+
+ def test_default_argument(self):
+ AggregateTestModel.objects.all().delete()
+ tests = [
+ (ArrayAgg("char_field", default=[""]), [""]),
+ (ArrayAgg("integer_field", default=[0]), [0]),
+ (ArrayAgg("boolean_field", default=[False]), [False]),
+ (BitAnd("integer_field", default=0), 0),
+ (BitOr("integer_field", default=0), 0),
+ (BoolAnd("boolean_field", default=False), False),
+ (BoolOr("boolean_field", default=False), False),
+ (JSONBAgg("integer_field", default=[""]), [""]),
+ (
+ JSONBAgg("integer_field", default=Value([""], JSONField())),
+ [""],
+ ),
+ (StringAgg("char_field", delimiter=";", default=""), ""),
+ (
+ StringAgg("char_field", delimiter=";", default=Value("")),
+ "",
+ ),
+ ]
+ if connection.features.has_bit_xor:
+ tests.append((BitXor("integer_field", default=0), 0))
+ for aggregation, expected_result in tests:
+ with self.subTest(aggregation=aggregation):
+ # Empty result with non-execution optimization.
+ with self.assertNumQueries(0):
+ values = AggregateTestModel.objects.none().aggregate(
+ aggregation=aggregation,
+ )
+ self.assertEqual(values, {"aggregation": expected_result})
+ # Empty result when query must be executed.
+ with transaction.atomic(), self.assertNumQueries(1):
+ values = AggregateTestModel.objects.aggregate(
+ aggregation=aggregation,
+ )
+ self.assertEqual(values, {"aggregation": expected_result})
+
+ @ignore_warnings(category=RemovedInDjango51Warning)
+ def test_jsonb_agg_default_str_value(self):
+ AggregateTestModel.objects.all().delete()
+ queryset = AggregateTestModel.objects.all()
+ self.assertEqual(
+ queryset.aggregate(
+ aggregation=JSONBAgg("integer_field", default=Value(""))
+ ),
+ {"aggregation": ""},
+ )
+
+ def test_jsonb_agg_default_str_value_deprecation(self):
+ queryset = AggregateTestModel.objects.all()
+ msg = (
+ "Passing a Value() with an output_field that isn't a JSONField as "
+ "JSONBAgg(default) is deprecated. Pass default=Value('', "
+ "output_field=JSONField()) instead."
+ )
+ with self.assertWarnsMessage(RemovedInDjango51Warning, msg):
+ queryset.aggregate(
+ aggregation=JSONBAgg("integer_field", default=Value(""))
+ )
+ with self.assertWarnsMessage(RemovedInDjango51Warning, msg):
+ queryset.none().aggregate(
+ aggregation=JSONBAgg("integer_field", default=Value(""))
+ ),
+
+ @ignore_warnings(category=RemovedInDjango51Warning)
+ def test_jsonb_agg_default_encoded_json_string(self):
+ AggregateTestModel.objects.all().delete()
+ queryset = AggregateTestModel.objects.all()
+ self.assertEqual(
+ queryset.aggregate(
+ aggregation=JSONBAgg("integer_field", default=Value("[]"))
+ ),
+ {"aggregation": []},
+ )
+
+ def test_jsonb_agg_default_encoded_json_string_deprecation(self):
+ queryset = AggregateTestModel.objects.all()
+ msg = (
+ "Passing an encoded JSON string as JSONBAgg(default) is deprecated. Pass "
+ "default=[] instead."
+ )
+ with self.assertWarnsMessage(RemovedInDjango51Warning, msg):
+ queryset.aggregate(
+ aggregation=JSONBAgg("integer_field", default=Value("[]"))
+ )
+ with self.assertWarnsMessage(RemovedInDjango51Warning, msg):
+ queryset.none().aggregate(
+ aggregation=JSONBAgg("integer_field", default=Value("[]"))
+ )
+
+ def test_array_agg_charfield(self):
+ values = AggregateTestModel.objects.aggregate(arrayagg=ArrayAgg("char_field"))
+ self.assertEqual(values, {"arrayagg": ["Foo1", "Foo2", "Foo4", "Foo3"]})
+
+ def test_array_agg_charfield_ordering(self):
+ ordering_test_cases = (
+ (F("char_field").desc(), ["Foo4", "Foo3", "Foo2", "Foo1"]),
+ (F("char_field").asc(), ["Foo1", "Foo2", "Foo3", "Foo4"]),
+ (F("char_field"), ["Foo1", "Foo2", "Foo3", "Foo4"]),
+ (
+ [F("boolean_field"), F("char_field").desc()],
+ ["Foo4", "Foo2", "Foo3", "Foo1"],
+ ),
+ (
+ (F("boolean_field"), F("char_field").desc()),
+ ["Foo4", "Foo2", "Foo3", "Foo1"],
+ ),
+ ("char_field", ["Foo1", "Foo2", "Foo3", "Foo4"]),
+ ("-char_field", ["Foo4", "Foo3", "Foo2", "Foo1"]),
+ (Concat("char_field", Value("@")), ["Foo1", "Foo2", "Foo3", "Foo4"]),
+ (Concat("char_field", Value("@")).desc(), ["Foo4", "Foo3", "Foo2", "Foo1"]),
+ (
+ (
+ Substr("char_field", 1, 1),
+ F("integer_field"),
+ Substr("char_field", 4, 1).desc(),
+ ),
+ ["Foo3", "Foo1", "Foo2", "Foo4"],
+ ),
+ )
+ for ordering, expected_output in ordering_test_cases:
+ with self.subTest(ordering=ordering, expected_output=expected_output):
+ values = AggregateTestModel.objects.aggregate(
+ arrayagg=ArrayAgg("char_field", ordering=ordering)
+ )
+ self.assertEqual(values, {"arrayagg": expected_output})
+
+ def test_array_agg_integerfield(self):
+ values = AggregateTestModel.objects.aggregate(
+ arrayagg=ArrayAgg("integer_field")
+ )
+ self.assertEqual(values, {"arrayagg": [0, 1, 2, 0]})
+
+ def test_array_agg_integerfield_ordering(self):
+ values = AggregateTestModel.objects.aggregate(
+ arrayagg=ArrayAgg("integer_field", ordering=F("integer_field").desc())
+ )
+ self.assertEqual(values, {"arrayagg": [2, 1, 0, 0]})
+
+ def test_array_agg_booleanfield(self):
+ values = AggregateTestModel.objects.aggregate(
+ arrayagg=ArrayAgg("boolean_field")
+ )
+ self.assertEqual(values, {"arrayagg": [True, False, False, True]})
+
+ def test_array_agg_booleanfield_ordering(self):
+ ordering_test_cases = (
+ (F("boolean_field").asc(), [False, False, True, True]),
+ (F("boolean_field").desc(), [True, True, False, False]),
+ (F("boolean_field"), [False, False, True, True]),
+ )
+ for ordering, expected_output in ordering_test_cases:
+ with self.subTest(ordering=ordering, expected_output=expected_output):
+ values = AggregateTestModel.objects.aggregate(
+ arrayagg=ArrayAgg("boolean_field", ordering=ordering)
+ )
+ self.assertEqual(values, {"arrayagg": expected_output})
+
+ def test_array_agg_jsonfield(self):
+ values = AggregateTestModel.objects.aggregate(
+ arrayagg=ArrayAgg(
+ KeyTransform("lang", "json_field"),
+ filter=Q(json_field__lang__isnull=False),
+ ),
+ )
+ self.assertEqual(values, {"arrayagg": ["pl", "en"]})
+
+ def test_array_agg_jsonfield_ordering(self):
+ values = AggregateTestModel.objects.aggregate(
+ arrayagg=ArrayAgg(
+ KeyTransform("lang", "json_field"),
+ filter=Q(json_field__lang__isnull=False),
+ ordering=KeyTransform("lang", "json_field"),
+ ),
+ )
+ self.assertEqual(values, {"arrayagg": ["en", "pl"]})
+
+ def test_array_agg_filter(self):
+ values = AggregateTestModel.objects.aggregate(
+ arrayagg=ArrayAgg("integer_field", filter=Q(integer_field__gt=0)),
+ )
+ self.assertEqual(values, {"arrayagg": [1, 2]})
+
+ def test_array_agg_lookups(self):
+ aggr1 = AggregateTestModel.objects.create()
+ aggr2 = AggregateTestModel.objects.create()
+ StatTestModel.objects.create(related_field=aggr1, int1=1, int2=0)
+ StatTestModel.objects.create(related_field=aggr1, int1=2, int2=0)
+ StatTestModel.objects.create(related_field=aggr2, int1=3, int2=0)
+ StatTestModel.objects.create(related_field=aggr2, int1=4, int2=0)
+ qs = (
+ StatTestModel.objects.values("related_field")
+ .annotate(array=ArrayAgg("int1"))
+ .filter(array__overlap=[2])
+ .values_list("array", flat=True)
+ )
+ self.assertCountEqual(qs.get(), [1, 2])
+
+ def test_array_agg_filter_index(self):
+ aggr1 = AggregateTestModel.objects.create(integer_field=1)
+ aggr2 = AggregateTestModel.objects.create(integer_field=2)
+ StatTestModel.objects.bulk_create(
+ [
+ StatTestModel(related_field=aggr1, int1=1, int2=0),
+ StatTestModel(related_field=aggr1, int1=2, int2=1),
+ StatTestModel(related_field=aggr2, int1=3, int2=0),
+ StatTestModel(related_field=aggr2, int1=4, int2=1),
+ ]
+ )
+ qs = (
+ AggregateTestModel.objects.filter(pk__in=[aggr1.pk, aggr2.pk])
+ .annotate(
+ array=ArrayAgg("stattestmodel__int1", filter=Q(stattestmodel__int2=0))
+ )
+ .annotate(array_value=F("array__0"))
+ .values_list("array_value", flat=True)
+ )
+ self.assertCountEqual(qs, [1, 3])
+
+ def test_array_agg_filter_slice(self):
+ aggr1 = AggregateTestModel.objects.create(integer_field=1)
+ aggr2 = AggregateTestModel.objects.create(integer_field=2)
+ StatTestModel.objects.bulk_create(
+ [
+ StatTestModel(related_field=aggr1, int1=1, int2=0),
+ StatTestModel(related_field=aggr1, int1=2, int2=1),
+ StatTestModel(related_field=aggr2, int1=3, int2=0),
+ StatTestModel(related_field=aggr2, int1=4, int2=1),
+ StatTestModel(related_field=aggr2, int1=5, int2=0),
+ ]
+ )
+ qs = (
+ AggregateTestModel.objects.filter(pk__in=[aggr1.pk, aggr2.pk])
+ .annotate(
+ array=ArrayAgg("stattestmodel__int1", filter=Q(stattestmodel__int2=0))
+ )
+ .annotate(array_value=F("array__1_2"))
+ .values_list("array_value", flat=True)
+ )
+ self.assertCountEqual(qs, [[], [5]])
+
+ def test_bit_and_general(self):
+ values = AggregateTestModel.objects.filter(integer_field__in=[0, 1]).aggregate(
+ bitand=BitAnd("integer_field")
+ )
+ self.assertEqual(values, {"bitand": 0})
+
+ def test_bit_and_on_only_true_values(self):
+ values = AggregateTestModel.objects.filter(integer_field=1).aggregate(
+ bitand=BitAnd("integer_field")
+ )
+ self.assertEqual(values, {"bitand": 1})
+
+ def test_bit_and_on_only_false_values(self):
+ values = AggregateTestModel.objects.filter(integer_field=0).aggregate(
+ bitand=BitAnd("integer_field")
+ )
+ self.assertEqual(values, {"bitand": 0})
+
+ def test_bit_or_general(self):
+ values = AggregateTestModel.objects.filter(integer_field__in=[0, 1]).aggregate(
+ bitor=BitOr("integer_field")
+ )
+ self.assertEqual(values, {"bitor": 1})
+
+ def test_bit_or_on_only_true_values(self):
+ values = AggregateTestModel.objects.filter(integer_field=1).aggregate(
+ bitor=BitOr("integer_field")
+ )
+ self.assertEqual(values, {"bitor": 1})
+
+ def test_bit_or_on_only_false_values(self):
+ values = AggregateTestModel.objects.filter(integer_field=0).aggregate(
+ bitor=BitOr("integer_field")
+ )
+ self.assertEqual(values, {"bitor": 0})
+
+ @skipUnlessDBFeature("has_bit_xor")
+ def test_bit_xor_general(self):
+ AggregateTestModel.objects.create(integer_field=3)
+ values = AggregateTestModel.objects.filter(
+ integer_field__in=[1, 3],
+ ).aggregate(bitxor=BitXor("integer_field"))
+ self.assertEqual(values, {"bitxor": 2})
+
+ @skipUnlessDBFeature("has_bit_xor")
+ def test_bit_xor_on_only_true_values(self):
+ values = AggregateTestModel.objects.filter(
+ integer_field=1,
+ ).aggregate(bitxor=BitXor("integer_field"))
+ self.assertEqual(values, {"bitxor": 1})
+
+ @skipUnlessDBFeature("has_bit_xor")
+ def test_bit_xor_on_only_false_values(self):
+ values = AggregateTestModel.objects.filter(
+ integer_field=0,
+ ).aggregate(bitxor=BitXor("integer_field"))
+ self.assertEqual(values, {"bitxor": 0})
+
+ def test_bool_and_general(self):
+ values = AggregateTestModel.objects.aggregate(booland=BoolAnd("boolean_field"))
+ self.assertEqual(values, {"booland": False})
+
+ def test_bool_and_q_object(self):
+ values = AggregateTestModel.objects.aggregate(
+ booland=BoolAnd(Q(integer_field__gt=2)),
+ )
+ self.assertEqual(values, {"booland": False})
+
+ def test_bool_or_general(self):
+ values = AggregateTestModel.objects.aggregate(boolor=BoolOr("boolean_field"))
+ self.assertEqual(values, {"boolor": True})
+
+ def test_bool_or_q_object(self):
+ values = AggregateTestModel.objects.aggregate(
+ boolor=BoolOr(Q(integer_field__gt=2)),
+ )
+ self.assertEqual(values, {"boolor": False})
+
+ def test_string_agg_requires_delimiter(self):
+ with self.assertRaises(TypeError):
+ AggregateTestModel.objects.aggregate(stringagg=StringAgg("char_field"))
+
+ def test_string_agg_delimiter_escaping(self):
+ values = AggregateTestModel.objects.aggregate(
+ stringagg=StringAgg("char_field", delimiter="'")
+ )
+ self.assertEqual(values, {"stringagg": "Foo1'Foo2'Foo4'Foo3"})
+
+ def test_string_agg_charfield(self):
+ values = AggregateTestModel.objects.aggregate(
+ stringagg=StringAgg("char_field", delimiter=";")
+ )
+ self.assertEqual(values, {"stringagg": "Foo1;Foo2;Foo4;Foo3"})
+
+ def test_string_agg_default_output_field(self):
+ values = AggregateTestModel.objects.aggregate(
+ stringagg=StringAgg("text_field", delimiter=";"),
+ )
+ self.assertEqual(values, {"stringagg": "Text1;Text2;Text4;Text3"})
+
+ def test_string_agg_charfield_ordering(self):
+ ordering_test_cases = (
+ (F("char_field").desc(), "Foo4;Foo3;Foo2;Foo1"),
+ (F("char_field").asc(), "Foo1;Foo2;Foo3;Foo4"),
+ (F("char_field"), "Foo1;Foo2;Foo3;Foo4"),
+ ("char_field", "Foo1;Foo2;Foo3;Foo4"),
+ ("-char_field", "Foo4;Foo3;Foo2;Foo1"),
+ (Concat("char_field", Value("@")), "Foo1;Foo2;Foo3;Foo4"),
+ (Concat("char_field", Value("@")).desc(), "Foo4;Foo3;Foo2;Foo1"),
+ )
+ for ordering, expected_output in ordering_test_cases:
+ with self.subTest(ordering=ordering, expected_output=expected_output):
+ values = AggregateTestModel.objects.aggregate(
+ stringagg=StringAgg("char_field", delimiter=";", ordering=ordering)
+ )
+ self.assertEqual(values, {"stringagg": expected_output})
+
+ def test_string_agg_jsonfield_ordering(self):
+ values = AggregateTestModel.objects.aggregate(
+ stringagg=StringAgg(
+ KeyTextTransform("lang", "json_field"),
+ delimiter=";",
+ ordering=KeyTextTransform("lang", "json_field"),
+ output_field=CharField(),
+ ),
+ )
+ self.assertEqual(values, {"stringagg": "en;pl"})
+
+ def test_string_agg_filter(self):
+ values = AggregateTestModel.objects.aggregate(
+ stringagg=StringAgg(
+ "char_field",
+ delimiter=";",
+ filter=Q(char_field__endswith="3") | Q(char_field__endswith="1"),
+ )
+ )
+ self.assertEqual(values, {"stringagg": "Foo1;Foo3"})
+
+ def test_orderable_agg_alternative_fields(self):
+ values = AggregateTestModel.objects.aggregate(
+ arrayagg=ArrayAgg("integer_field", ordering=F("char_field").asc())
+ )
+ self.assertEqual(values, {"arrayagg": [0, 1, 0, 2]})
+
+ def test_jsonb_agg(self):
+ values = AggregateTestModel.objects.aggregate(jsonbagg=JSONBAgg("char_field"))
+ self.assertEqual(values, {"jsonbagg": ["Foo1", "Foo2", "Foo4", "Foo3"]})
+
+ def test_jsonb_agg_charfield_ordering(self):
+ ordering_test_cases = (
+ (F("char_field").desc(), ["Foo4", "Foo3", "Foo2", "Foo1"]),
+ (F("char_field").asc(), ["Foo1", "Foo2", "Foo3", "Foo4"]),
+ (F("char_field"), ["Foo1", "Foo2", "Foo3", "Foo4"]),
+ ("char_field", ["Foo1", "Foo2", "Foo3", "Foo4"]),
+ ("-char_field", ["Foo4", "Foo3", "Foo2", "Foo1"]),
+ (Concat("char_field", Value("@")), ["Foo1", "Foo2", "Foo3", "Foo4"]),
+ (Concat("char_field", Value("@")).desc(), ["Foo4", "Foo3", "Foo2", "Foo1"]),
+ )
+ for ordering, expected_output in ordering_test_cases:
+ with self.subTest(ordering=ordering, expected_output=expected_output):
+ values = AggregateTestModel.objects.aggregate(
+ jsonbagg=JSONBAgg("char_field", ordering=ordering),
+ )
+ self.assertEqual(values, {"jsonbagg": expected_output})
+
+ def test_jsonb_agg_integerfield_ordering(self):
+ values = AggregateTestModel.objects.aggregate(
+ jsonbagg=JSONBAgg("integer_field", ordering=F("integer_field").desc()),
+ )
+ self.assertEqual(values, {"jsonbagg": [2, 1, 0, 0]})
+
+ def test_jsonb_agg_booleanfield_ordering(self):
+ ordering_test_cases = (
+ (F("boolean_field").asc(), [False, False, True, True]),
+ (F("boolean_field").desc(), [True, True, False, False]),
+ (F("boolean_field"), [False, False, True, True]),
+ )
+ for ordering, expected_output in ordering_test_cases:
+ with self.subTest(ordering=ordering, expected_output=expected_output):
+ values = AggregateTestModel.objects.aggregate(
+ jsonbagg=JSONBAgg("boolean_field", ordering=ordering),
+ )
+ self.assertEqual(values, {"jsonbagg": expected_output})
+
+ def test_jsonb_agg_jsonfield_ordering(self):
+ values = AggregateTestModel.objects.aggregate(
+ jsonbagg=JSONBAgg(
+ KeyTransform("lang", "json_field"),
+ filter=Q(json_field__lang__isnull=False),
+ ordering=KeyTransform("lang", "json_field"),
+ ),
+ )
+ self.assertEqual(values, {"jsonbagg": ["en", "pl"]})
+
+ def test_jsonb_agg_key_index_transforms(self):
+ room101 = Room.objects.create(number=101)
+ room102 = Room.objects.create(number=102)
+ datetimes = [
+ timezone.datetime(2018, 6, 20),
+ timezone.datetime(2018, 6, 24),
+ timezone.datetime(2018, 6, 28),
+ ]
+ HotelReservation.objects.create(
+ datespan=(datetimes[0].date(), datetimes[1].date()),
+ start=datetimes[0],
+ end=datetimes[1],
+ room=room102,
+ requirements={"double_bed": True, "parking": True},
+ )
+ HotelReservation.objects.create(
+ datespan=(datetimes[1].date(), datetimes[2].date()),
+ start=datetimes[1],
+ end=datetimes[2],
+ room=room102,
+ requirements={"double_bed": False, "sea_view": True, "parking": False},
+ )
+ HotelReservation.objects.create(
+ datespan=(datetimes[0].date(), datetimes[2].date()),
+ start=datetimes[0],
+ end=datetimes[2],
+ room=room101,
+ requirements={"sea_view": False},
+ )
+ values = (
+ Room.objects.annotate(
+ requirements=JSONBAgg(
+ "hotelreservation__requirements",
+ ordering="-hotelreservation__start",
+ )
+ )
+ .filter(requirements__0__sea_view=True)
+ .values("number", "requirements")
+ )
+ self.assertSequenceEqual(
+ values,
+ [
+ {
+ "number": 102,
+ "requirements": [
+ {"double_bed": False, "sea_view": True, "parking": False},
+ {"double_bed": True, "parking": True},
+ ],
+ },
+ ],
+ )
+
+ def test_string_agg_array_agg_ordering_in_subquery(self):
+ stats = []
+ for i, agg in enumerate(AggregateTestModel.objects.order_by("char_field")):
+ stats.append(StatTestModel(related_field=agg, int1=i, int2=i + 1))
+ stats.append(StatTestModel(related_field=agg, int1=i + 1, int2=i))
+ StatTestModel.objects.bulk_create(stats)
+
+ for aggregate, expected_result in (
+ (
+ ArrayAgg("stattestmodel__int1", ordering="-stattestmodel__int2"),
+ [
+ ("Foo1", [0, 1]),
+ ("Foo2", [1, 2]),
+ ("Foo3", [2, 3]),
+ ("Foo4", [3, 4]),
+ ],
+ ),
+ (
+ StringAgg(
+ Cast("stattestmodel__int1", CharField()),
+ delimiter=";",
+ ordering="-stattestmodel__int2",
+ ),
+ [("Foo1", "0;1"), ("Foo2", "1;2"), ("Foo3", "2;3"), ("Foo4", "3;4")],
+ ),
+ ):
+ with self.subTest(aggregate=aggregate.__class__.__name__):
+ subquery = (
+ AggregateTestModel.objects.filter(
+ pk=OuterRef("pk"),
+ )
+ .annotate(agg=aggregate)
+ .values("agg")
+ )
+ values = (
+ AggregateTestModel.objects.annotate(
+ agg=Subquery(subquery),
+ )
+ .order_by("char_field")
+ .values_list("char_field", "agg")
+ )
+ self.assertEqual(list(values), expected_result)
+
+ def test_string_agg_array_agg_filter_in_subquery(self):
+ StatTestModel.objects.bulk_create(
+ [
+ StatTestModel(related_field=self.aggs[0], int1=0, int2=5),
+ StatTestModel(related_field=self.aggs[0], int1=1, int2=4),
+ StatTestModel(related_field=self.aggs[0], int1=2, int2=3),
+ ]
+ )
+ for aggregate, expected_result in (
+ (
+ ArrayAgg("stattestmodel__int1", filter=Q(stattestmodel__int2__gt=3)),
+ [("Foo1", [0, 1]), ("Foo2", None)],
+ ),
+ (
+ StringAgg(
+ Cast("stattestmodel__int2", CharField()),
+ delimiter=";",
+ filter=Q(stattestmodel__int1__lt=2),
+ ),
+ [("Foo1", "5;4"), ("Foo2", None)],
+ ),
+ ):
+ with self.subTest(aggregate=aggregate.__class__.__name__):
+ subquery = (
+ AggregateTestModel.objects.filter(
+ pk=OuterRef("pk"),
+ )
+ .annotate(agg=aggregate)
+ .values("agg")
+ )
+ values = (
+ AggregateTestModel.objects.annotate(
+ agg=Subquery(subquery),
+ )
+ .filter(
+ char_field__in=["Foo1", "Foo2"],
+ )
+ .order_by("char_field")
+ .values_list("char_field", "agg")
+ )
+ self.assertEqual(list(values), expected_result)
+
+ def test_string_agg_filter_in_subquery_with_exclude(self):
+ subquery = (
+ AggregateTestModel.objects.annotate(
+ stringagg=StringAgg(
+ "char_field",
+ delimiter=";",
+ filter=Q(char_field__endswith="1"),
+ )
+ )
+ .exclude(stringagg="")
+ .values("id")
+ )
+ self.assertSequenceEqual(
+ AggregateTestModel.objects.filter(id__in=Subquery(subquery)),
+ [self.aggs[0]],
+ )
+
+ def test_ordering_isnt_cleared_for_array_subquery(self):
+ inner_qs = AggregateTestModel.objects.order_by("-integer_field")
+ qs = AggregateTestModel.objects.annotate(
+ integers=Func(
+ Subquery(inner_qs.values("integer_field")),
+ function="ARRAY",
+ output_field=ArrayField(base_field=IntegerField()),
+ ),
+ )
+ self.assertSequenceEqual(
+ qs.first().integers,
+ inner_qs.values_list("integer_field", flat=True),
+ )
+
+ def test_window(self):
+ self.assertCountEqual(
+ AggregateTestModel.objects.annotate(
+ integers=Window(
+ expression=ArrayAgg("char_field"),
+ partition_by=F("integer_field"),
+ )
+ ).values("integers", "char_field"),
+ [
+ {"integers": ["Foo1", "Foo3"], "char_field": "Foo1"},
+ {"integers": ["Foo1", "Foo3"], "char_field": "Foo3"},
+ {"integers": ["Foo2"], "char_field": "Foo2"},
+ {"integers": ["Foo4"], "char_field": "Foo4"},
+ ],
+ )
+
+ def test_values_list(self):
+ tests = [ArrayAgg("integer_field"), JSONBAgg("integer_field")]
+ for aggregation in tests:
+ with self.subTest(aggregation=aggregation):
+ self.assertCountEqual(
+ AggregateTestModel.objects.values_list(aggregation),
+ [([0],), ([1],), ([2],), ([0],)],
+ )
+
+
+class TestAggregateDistinct(PostgreSQLTestCase):
+ @classmethod
+ def setUpTestData(cls):
+ AggregateTestModel.objects.create(char_field="Foo")
+ AggregateTestModel.objects.create(char_field="Foo")
+ AggregateTestModel.objects.create(char_field="Bar")
+
+ def test_string_agg_distinct_false(self):
+ values = AggregateTestModel.objects.aggregate(
+ stringagg=StringAgg("char_field", delimiter=" ", distinct=False)
+ )
+ self.assertEqual(values["stringagg"].count("Foo"), 2)
+ self.assertEqual(values["stringagg"].count("Bar"), 1)
+
+ def test_string_agg_distinct_true(self):
+ values = AggregateTestModel.objects.aggregate(
+ stringagg=StringAgg("char_field", delimiter=" ", distinct=True)
+ )
+ self.assertEqual(values["stringagg"].count("Foo"), 1)
+ self.assertEqual(values["stringagg"].count("Bar"), 1)
+
+ def test_array_agg_distinct_false(self):
+ values = AggregateTestModel.objects.aggregate(
+ arrayagg=ArrayAgg("char_field", distinct=False)
+ )
+ self.assertEqual(sorted(values["arrayagg"]), ["Bar", "Foo", "Foo"])
+
+ def test_array_agg_distinct_true(self):
+ values = AggregateTestModel.objects.aggregate(
+ arrayagg=ArrayAgg("char_field", distinct=True)
+ )
+ self.assertEqual(sorted(values["arrayagg"]), ["Bar", "Foo"])
+
+ def test_jsonb_agg_distinct_false(self):
+ values = AggregateTestModel.objects.aggregate(
+ jsonbagg=JSONBAgg("char_field", distinct=False),
+ )
+ self.assertEqual(sorted(values["jsonbagg"]), ["Bar", "Foo", "Foo"])
+
+ def test_jsonb_agg_distinct_true(self):
+ values = AggregateTestModel.objects.aggregate(
+ jsonbagg=JSONBAgg("char_field", distinct=True),
+ )
+ self.assertEqual(sorted(values["jsonbagg"]), ["Bar", "Foo"])
+
+
+class TestStatisticsAggregate(PostgreSQLTestCase):
+ @classmethod
+ def setUpTestData(cls):
+ StatTestModel.objects.create(
+ int1=1,
+ int2=3,
+ related_field=AggregateTestModel.objects.create(integer_field=0),
+ )
+ StatTestModel.objects.create(
+ int1=2,
+ int2=2,
+ related_field=AggregateTestModel.objects.create(integer_field=1),
+ )
+ StatTestModel.objects.create(
+ int1=3,
+ int2=1,
+ related_field=AggregateTestModel.objects.create(integer_field=2),
+ )
+
+ # Tests for base class (StatAggregate)
+
+ def test_missing_arguments_raises_exception(self):
+ with self.assertRaisesMessage(ValueError, "Both y and x must be provided."):
+ StatAggregate(x=None, y=None)
+
+ def test_correct_source_expressions(self):
+ func = StatAggregate(x="test", y=13)
+ self.assertIsInstance(func.source_expressions[0], Value)
+ self.assertIsInstance(func.source_expressions[1], F)
+
+ def test_alias_is_required(self):
+ class SomeFunc(StatAggregate):
+ function = "TEST"
+
+ with self.assertRaisesMessage(TypeError, "Complex aggregates require an alias"):
+ StatTestModel.objects.aggregate(SomeFunc(y="int2", x="int1"))
+
+ # Test aggregates
+
+ def test_empty_result_set(self):
+ StatTestModel.objects.all().delete()
+ tests = [
+ (Corr(y="int2", x="int1"), None),
+ (CovarPop(y="int2", x="int1"), None),
+ (CovarPop(y="int2", x="int1", sample=True), None),
+ (RegrAvgX(y="int2", x="int1"), None),
+ (RegrAvgY(y="int2", x="int1"), None),
+ (RegrCount(y="int2", x="int1"), 0),
+ (RegrIntercept(y="int2", x="int1"), None),
+ (RegrR2(y="int2", x="int1"), None),
+ (RegrSlope(y="int2", x="int1"), None),
+ (RegrSXX(y="int2", x="int1"), None),
+ (RegrSXY(y="int2", x="int1"), None),
+ (RegrSYY(y="int2", x="int1"), None),
+ ]
+ for aggregation, expected_result in tests:
+ with self.subTest(aggregation=aggregation):
+ # Empty result with non-execution optimization.
+ with self.assertNumQueries(0):
+ values = StatTestModel.objects.none().aggregate(
+ aggregation=aggregation,
+ )
+ self.assertEqual(values, {"aggregation": expected_result})
+ # Empty result when query must be executed.
+ with self.assertNumQueries(1):
+ values = StatTestModel.objects.aggregate(
+ aggregation=aggregation,
+ )
+ self.assertEqual(values, {"aggregation": expected_result})
+
+ def test_default_argument(self):
+ StatTestModel.objects.all().delete()
+ tests = [
+ (Corr(y="int2", x="int1", default=0), 0),
+ (CovarPop(y="int2", x="int1", default=0), 0),
+ (CovarPop(y="int2", x="int1", sample=True, default=0), 0),
+ (RegrAvgX(y="int2", x="int1", default=0), 0),
+ (RegrAvgY(y="int2", x="int1", default=0), 0),
+ # RegrCount() doesn't support the default argument.
+ (RegrIntercept(y="int2", x="int1", default=0), 0),
+ (RegrR2(y="int2", x="int1", default=0), 0),
+ (RegrSlope(y="int2", x="int1", default=0), 0),
+ (RegrSXX(y="int2", x="int1", default=0), 0),
+ (RegrSXY(y="int2", x="int1", default=0), 0),
+ (RegrSYY(y="int2", x="int1", default=0), 0),
+ ]
+ for aggregation, expected_result in tests:
+ with self.subTest(aggregation=aggregation):
+ # Empty result with non-execution optimization.
+ with self.assertNumQueries(0):
+ values = StatTestModel.objects.none().aggregate(
+ aggregation=aggregation,
+ )
+ self.assertEqual(values, {"aggregation": expected_result})
+ # Empty result when query must be executed.
+ with self.assertNumQueries(1):
+ values = StatTestModel.objects.aggregate(
+ aggregation=aggregation,
+ )
+ self.assertEqual(values, {"aggregation": expected_result})
+
+ def test_corr_general(self):
+ values = StatTestModel.objects.aggregate(corr=Corr(y="int2", x="int1"))
+ self.assertEqual(values, {"corr": -1.0})
+
+ def test_covar_pop_general(self):
+ values = StatTestModel.objects.aggregate(covarpop=CovarPop(y="int2", x="int1"))
+ self.assertEqual(values, {"covarpop": Approximate(-0.66, places=1)})
+
+ def test_covar_pop_sample(self):
+ values = StatTestModel.objects.aggregate(
+ covarpop=CovarPop(y="int2", x="int1", sample=True)
+ )
+ self.assertEqual(values, {"covarpop": -1.0})
+
+ def test_regr_avgx_general(self):
+ values = StatTestModel.objects.aggregate(regravgx=RegrAvgX(y="int2", x="int1"))
+ self.assertEqual(values, {"regravgx": 2.0})
+
+ def test_regr_avgy_general(self):
+ values = StatTestModel.objects.aggregate(regravgy=RegrAvgY(y="int2", x="int1"))
+ self.assertEqual(values, {"regravgy": 2.0})
+
+ def test_regr_count_general(self):
+ values = StatTestModel.objects.aggregate(
+ regrcount=RegrCount(y="int2", x="int1")
+ )
+ self.assertEqual(values, {"regrcount": 3})
+
+ def test_regr_count_default(self):
+ msg = "RegrCount does not allow default."
+ with self.assertRaisesMessage(TypeError, msg):
+ RegrCount(y="int2", x="int1", default=0)
+
+ def test_regr_intercept_general(self):
+ values = StatTestModel.objects.aggregate(
+ regrintercept=RegrIntercept(y="int2", x="int1")
+ )
+ self.assertEqual(values, {"regrintercept": 4})
+
+ def test_regr_r2_general(self):
+ values = StatTestModel.objects.aggregate(regrr2=RegrR2(y="int2", x="int1"))
+ self.assertEqual(values, {"regrr2": 1})
+
+ def test_regr_slope_general(self):
+ values = StatTestModel.objects.aggregate(
+ regrslope=RegrSlope(y="int2", x="int1")
+ )
+ self.assertEqual(values, {"regrslope": -1})
+
+ def test_regr_sxx_general(self):
+ values = StatTestModel.objects.aggregate(regrsxx=RegrSXX(y="int2", x="int1"))
+ self.assertEqual(values, {"regrsxx": 2.0})
+
+ def test_regr_sxy_general(self):
+ values = StatTestModel.objects.aggregate(regrsxy=RegrSXY(y="int2", x="int1"))
+ self.assertEqual(values, {"regrsxy": -2.0})
+
+ def test_regr_syy_general(self):
+ values = StatTestModel.objects.aggregate(regrsyy=RegrSYY(y="int2", x="int1"))
+ self.assertEqual(values, {"regrsyy": 2.0})
+
+ def test_regr_avgx_with_related_obj_and_number_as_argument(self):
+ """
+ This is more complex test to check if JOIN on field and
+ number as argument works as expected.
+ """
+ values = StatTestModel.objects.aggregate(
+ complex_regravgx=RegrAvgX(y=5, x="related_field__integer_field")
+ )
+ self.assertEqual(values, {"complex_regravgx": 1.0})
diff --git a/testbed/django__django/tests/postgres_tests/test_apps.py b/testbed/django__django/tests/postgres_tests/test_apps.py
new file mode 100644
index 0000000000000000000000000000000000000000..3fdd7c3faf0d6334e6bd64f1415725cc3777a09f
--- /dev/null
+++ b/testbed/django__django/tests/postgres_tests/test_apps.py
@@ -0,0 +1,81 @@
+import unittest
+from decimal import Decimal
+
+from django.db import connection
+from django.db.backends.signals import connection_created
+from django.db.migrations.writer import MigrationWriter
+from django.test import TestCase
+from django.test.utils import modify_settings
+
+try:
+ from django.contrib.postgres.fields import (
+ DateRangeField,
+ DateTimeRangeField,
+ DecimalRangeField,
+ IntegerRangeField,
+ )
+ from django.db.backends.postgresql.psycopg_any import (
+ DateRange,
+ DateTimeRange,
+ DateTimeTZRange,
+ NumericRange,
+ is_psycopg3,
+ )
+except ImportError:
+ pass
+
+
+@unittest.skipUnless(connection.vendor == "postgresql", "PostgreSQL specific tests")
+class PostgresConfigTests(TestCase):
+ def test_register_type_handlers_connection(self):
+ from django.contrib.postgres.signals import register_type_handlers
+
+ self.assertNotIn(
+ register_type_handlers, connection_created._live_receivers(None)[0]
+ )
+ with modify_settings(INSTALLED_APPS={"append": "django.contrib.postgres"}):
+ self.assertIn(
+ register_type_handlers, connection_created._live_receivers(None)[0]
+ )
+ self.assertNotIn(
+ register_type_handlers, connection_created._live_receivers(None)[0]
+ )
+
+ def test_register_serializer_for_migrations(self):
+ tests = (
+ (DateRange(empty=True), DateRangeField),
+ (DateTimeRange(empty=True), DateRangeField),
+ (DateTimeTZRange(None, None, "[]"), DateTimeRangeField),
+ (NumericRange(Decimal("1.0"), Decimal("5.0"), "()"), DecimalRangeField),
+ (NumericRange(1, 10), IntegerRangeField),
+ )
+
+ def assertNotSerializable():
+ for default, test_field in tests:
+ with self.subTest(default=default):
+ field = test_field(default=default)
+ with self.assertRaisesMessage(
+ ValueError, "Cannot serialize: %s" % default.__class__.__name__
+ ):
+ MigrationWriter.serialize(field)
+
+ assertNotSerializable()
+ import_name = "psycopg.types.range" if is_psycopg3 else "psycopg2.extras"
+ with self.modify_settings(INSTALLED_APPS={"append": "django.contrib.postgres"}):
+ for default, test_field in tests:
+ with self.subTest(default=default):
+ field = test_field(default=default)
+ serialized_field, imports = MigrationWriter.serialize(field)
+ self.assertEqual(
+ imports,
+ {
+ "import django.contrib.postgres.fields.ranges",
+ f"import {import_name}",
+ },
+ )
+ self.assertIn(
+ f"{field.__module__}.{field.__class__.__name__}"
+ f"(default={import_name}.{default!r})",
+ serialized_field,
+ )
+ assertNotSerializable()
diff --git a/testbed/django__django/tests/postgres_tests/test_array.py b/testbed/django__django/tests/postgres_tests/test_array.py
new file mode 100644
index 0000000000000000000000000000000000000000..48b03c626a9d09efcb4ca67777f7f2c6aff123b4
--- /dev/null
+++ b/testbed/django__django/tests/postgres_tests/test_array.py
@@ -0,0 +1,1480 @@
+import decimal
+import enum
+import json
+import unittest
+import uuid
+
+from django import forms
+from django.contrib.admin.utils import display_for_field
+from django.core import checks, exceptions, serializers, validators
+from django.core.exceptions import FieldError
+from django.core.management import call_command
+from django.db import IntegrityError, connection, models
+from django.db.models.expressions import Exists, OuterRef, RawSQL, Value
+from django.db.models.functions import Cast, JSONObject, Upper
+from django.test import TransactionTestCase, override_settings, skipUnlessDBFeature
+from django.test.utils import isolate_apps
+from django.utils import timezone
+
+from . import PostgreSQLSimpleTestCase, PostgreSQLTestCase, PostgreSQLWidgetTestCase
+from .models import (
+ ArrayEnumModel,
+ ArrayFieldSubclass,
+ CharArrayModel,
+ DateTimeArrayModel,
+ IntegerArrayModel,
+ NestedIntegerArrayModel,
+ NullableIntegerArrayModel,
+ OtherTypesArrayModel,
+ PostgreSQLModel,
+ Tag,
+)
+
+try:
+ from django.contrib.postgres.aggregates import ArrayAgg
+ from django.contrib.postgres.expressions import ArraySubquery
+ from django.contrib.postgres.fields import ArrayField
+ from django.contrib.postgres.fields.array import IndexTransform, SliceTransform
+ from django.contrib.postgres.forms import (
+ SimpleArrayField,
+ SplitArrayField,
+ SplitArrayWidget,
+ )
+ from django.db.backends.postgresql.psycopg_any import NumericRange
+except ImportError:
+ pass
+
+
+@isolate_apps("postgres_tests")
+class BasicTests(PostgreSQLSimpleTestCase):
+ def test_get_field_display(self):
+ class MyModel(PostgreSQLModel):
+ field = ArrayField(
+ models.CharField(max_length=16),
+ choices=[
+ ["Media", [(["vinyl", "cd"], "Audio")]],
+ (("mp3", "mp4"), "Digital"),
+ ],
+ )
+
+ tests = (
+ (["vinyl", "cd"], "Audio"),
+ (("mp3", "mp4"), "Digital"),
+ (("a", "b"), "('a', 'b')"),
+ (["c", "d"], "['c', 'd']"),
+ )
+ for value, display in tests:
+ with self.subTest(value=value, display=display):
+ instance = MyModel(field=value)
+ self.assertEqual(instance.get_field_display(), display)
+
+ def test_get_field_display_nested_array(self):
+ class MyModel(PostgreSQLModel):
+ field = ArrayField(
+ ArrayField(models.CharField(max_length=16)),
+ choices=[
+ [
+ "Media",
+ [([["vinyl", "cd"], ("x",)], "Audio")],
+ ],
+ ((["mp3"], ("mp4",)), "Digital"),
+ ],
+ )
+
+ tests = (
+ ([["vinyl", "cd"], ("x",)], "Audio"),
+ ((["mp3"], ("mp4",)), "Digital"),
+ ((("a", "b"), ("c",)), "(('a', 'b'), ('c',))"),
+ ([["a", "b"], ["c"]], "[['a', 'b'], ['c']]"),
+ )
+ for value, display in tests:
+ with self.subTest(value=value, display=display):
+ instance = MyModel(field=value)
+ self.assertEqual(instance.get_field_display(), display)
+
+
+class TestSaveLoad(PostgreSQLTestCase):
+ def test_integer(self):
+ instance = IntegerArrayModel(field=[1, 2, 3])
+ instance.save()
+ loaded = IntegerArrayModel.objects.get()
+ self.assertEqual(instance.field, loaded.field)
+
+ def test_char(self):
+ instance = CharArrayModel(field=["hello", "goodbye"])
+ instance.save()
+ loaded = CharArrayModel.objects.get()
+ self.assertEqual(instance.field, loaded.field)
+
+ def test_dates(self):
+ instance = DateTimeArrayModel(
+ datetimes=[timezone.now()],
+ dates=[timezone.now().date()],
+ times=[timezone.now().time()],
+ )
+ instance.save()
+ loaded = DateTimeArrayModel.objects.get()
+ self.assertEqual(instance.datetimes, loaded.datetimes)
+ self.assertEqual(instance.dates, loaded.dates)
+ self.assertEqual(instance.times, loaded.times)
+
+ def test_tuples(self):
+ instance = IntegerArrayModel(field=(1,))
+ instance.save()
+ loaded = IntegerArrayModel.objects.get()
+ self.assertSequenceEqual(instance.field, loaded.field)
+
+ def test_integers_passed_as_strings(self):
+ # This checks that get_prep_value is deferred properly
+ instance = IntegerArrayModel(field=["1"])
+ instance.save()
+ loaded = IntegerArrayModel.objects.get()
+ self.assertEqual(loaded.field, [1])
+
+ def test_default_null(self):
+ instance = NullableIntegerArrayModel()
+ instance.save()
+ loaded = NullableIntegerArrayModel.objects.get(pk=instance.pk)
+ self.assertIsNone(loaded.field)
+ self.assertEqual(instance.field, loaded.field)
+
+ def test_null_handling(self):
+ instance = NullableIntegerArrayModel(field=None)
+ instance.save()
+ loaded = NullableIntegerArrayModel.objects.get()
+ self.assertEqual(instance.field, loaded.field)
+
+ instance = IntegerArrayModel(field=None)
+ with self.assertRaises(IntegrityError):
+ instance.save()
+
+ def test_nested(self):
+ instance = NestedIntegerArrayModel(field=[[1, 2], [3, 4]])
+ instance.save()
+ loaded = NestedIntegerArrayModel.objects.get()
+ self.assertEqual(instance.field, loaded.field)
+
+ def test_other_array_types(self):
+ instance = OtherTypesArrayModel(
+ ips=["192.168.0.1", "::1"],
+ uuids=[uuid.uuid4()],
+ decimals=[decimal.Decimal(1.25), 1.75],
+ tags=[Tag(1), Tag(2), Tag(3)],
+ json=[{"a": 1}, {"b": 2}],
+ int_ranges=[NumericRange(10, 20), NumericRange(30, 40)],
+ bigint_ranges=[
+ NumericRange(7000000000, 10000000000),
+ NumericRange(50000000000, 70000000000),
+ ],
+ )
+ instance.save()
+ loaded = OtherTypesArrayModel.objects.get()
+ self.assertEqual(instance.ips, loaded.ips)
+ self.assertEqual(instance.uuids, loaded.uuids)
+ self.assertEqual(instance.decimals, loaded.decimals)
+ self.assertEqual(instance.tags, loaded.tags)
+ self.assertEqual(instance.json, loaded.json)
+ self.assertEqual(instance.int_ranges, loaded.int_ranges)
+ self.assertEqual(instance.bigint_ranges, loaded.bigint_ranges)
+
+ def test_null_from_db_value_handling(self):
+ instance = OtherTypesArrayModel.objects.create(
+ ips=["192.168.0.1", "::1"],
+ uuids=[uuid.uuid4()],
+ decimals=[decimal.Decimal(1.25), 1.75],
+ tags=None,
+ )
+ instance.refresh_from_db()
+ self.assertIsNone(instance.tags)
+ self.assertEqual(instance.json, [])
+ self.assertIsNone(instance.int_ranges)
+ self.assertIsNone(instance.bigint_ranges)
+
+ def test_model_set_on_base_field(self):
+ instance = IntegerArrayModel()
+ field = instance._meta.get_field("field")
+ self.assertEqual(field.model, IntegerArrayModel)
+ self.assertEqual(field.base_field.model, IntegerArrayModel)
+
+ def test_nested_nullable_base_field(self):
+ instance = NullableIntegerArrayModel.objects.create(
+ field_nested=[[None, None], [None, None]],
+ )
+ self.assertEqual(instance.field_nested, [[None, None], [None, None]])
+
+
+class TestQuerying(PostgreSQLTestCase):
+ @classmethod
+ def setUpTestData(cls):
+ cls.objs = NullableIntegerArrayModel.objects.bulk_create(
+ [
+ NullableIntegerArrayModel(order=1, field=[1]),
+ NullableIntegerArrayModel(order=2, field=[2]),
+ NullableIntegerArrayModel(order=3, field=[2, 3]),
+ NullableIntegerArrayModel(order=4, field=[20, 30, 40]),
+ NullableIntegerArrayModel(order=5, field=None),
+ ]
+ )
+
+ def test_empty_list(self):
+ NullableIntegerArrayModel.objects.create(field=[])
+ obj = (
+ NullableIntegerArrayModel.objects.annotate(
+ empty_array=models.Value(
+ [], output_field=ArrayField(models.IntegerField())
+ ),
+ )
+ .filter(field=models.F("empty_array"))
+ .get()
+ )
+ self.assertEqual(obj.field, [])
+ self.assertEqual(obj.empty_array, [])
+
+ def test_exact(self):
+ self.assertSequenceEqual(
+ NullableIntegerArrayModel.objects.filter(field__exact=[1]), self.objs[:1]
+ )
+
+ def test_exact_null_only_array(self):
+ obj = NullableIntegerArrayModel.objects.create(
+ field=[None], field_nested=[None, None]
+ )
+ self.assertSequenceEqual(
+ NullableIntegerArrayModel.objects.filter(field__exact=[None]), [obj]
+ )
+ self.assertSequenceEqual(
+ NullableIntegerArrayModel.objects.filter(field_nested__exact=[None, None]),
+ [obj],
+ )
+
+ def test_exact_null_only_nested_array(self):
+ obj1 = NullableIntegerArrayModel.objects.create(field_nested=[[None, None]])
+ obj2 = NullableIntegerArrayModel.objects.create(
+ field_nested=[[None, None], [None, None]],
+ )
+ self.assertSequenceEqual(
+ NullableIntegerArrayModel.objects.filter(
+ field_nested__exact=[[None, None]],
+ ),
+ [obj1],
+ )
+ self.assertSequenceEqual(
+ NullableIntegerArrayModel.objects.filter(
+ field_nested__exact=[[None, None], [None, None]],
+ ),
+ [obj2],
+ )
+
+ def test_exact_with_expression(self):
+ self.assertSequenceEqual(
+ NullableIntegerArrayModel.objects.filter(field__exact=[Value(1)]),
+ self.objs[:1],
+ )
+
+ def test_exact_charfield(self):
+ instance = CharArrayModel.objects.create(field=["text"])
+ self.assertSequenceEqual(
+ CharArrayModel.objects.filter(field=["text"]), [instance]
+ )
+
+ def test_exact_nested(self):
+ instance = NestedIntegerArrayModel.objects.create(field=[[1, 2], [3, 4]])
+ self.assertSequenceEqual(
+ NestedIntegerArrayModel.objects.filter(field=[[1, 2], [3, 4]]), [instance]
+ )
+
+ def test_isnull(self):
+ self.assertSequenceEqual(
+ NullableIntegerArrayModel.objects.filter(field__isnull=True), self.objs[-1:]
+ )
+
+ def test_gt(self):
+ self.assertSequenceEqual(
+ NullableIntegerArrayModel.objects.filter(field__gt=[0]), self.objs[:4]
+ )
+
+ def test_lt(self):
+ self.assertSequenceEqual(
+ NullableIntegerArrayModel.objects.filter(field__lt=[2]), self.objs[:1]
+ )
+
+ def test_in(self):
+ self.assertSequenceEqual(
+ NullableIntegerArrayModel.objects.filter(field__in=[[1], [2]]),
+ self.objs[:2],
+ )
+
+ def test_in_subquery(self):
+ IntegerArrayModel.objects.create(field=[2, 3])
+ self.assertSequenceEqual(
+ NullableIntegerArrayModel.objects.filter(
+ field__in=IntegerArrayModel.objects.values_list("field", flat=True)
+ ),
+ self.objs[2:3],
+ )
+
+ @unittest.expectedFailure
+ def test_in_including_F_object(self):
+ # This test asserts that Array objects passed to filters can be
+ # constructed to contain F objects. This currently doesn't work as the
+ # psycopg mogrify method that generates the ARRAY() syntax is
+ # expecting literals, not column references (#27095).
+ self.assertSequenceEqual(
+ NullableIntegerArrayModel.objects.filter(field__in=[[models.F("id")]]),
+ self.objs[:2],
+ )
+
+ def test_in_as_F_object(self):
+ self.assertSequenceEqual(
+ NullableIntegerArrayModel.objects.filter(field__in=[models.F("field")]),
+ self.objs[:4],
+ )
+
+ def test_contained_by(self):
+ self.assertSequenceEqual(
+ NullableIntegerArrayModel.objects.filter(field__contained_by=[1, 2]),
+ self.objs[:2],
+ )
+
+ def test_contained_by_including_F_object(self):
+ self.assertSequenceEqual(
+ NullableIntegerArrayModel.objects.filter(
+ field__contained_by=[models.F("order"), 2]
+ ),
+ self.objs[:3],
+ )
+
+ def test_contains(self):
+ self.assertSequenceEqual(
+ NullableIntegerArrayModel.objects.filter(field__contains=[2]),
+ self.objs[1:3],
+ )
+
+ def test_contains_subquery(self):
+ IntegerArrayModel.objects.create(field=[2, 3])
+ inner_qs = IntegerArrayModel.objects.values_list("field", flat=True)
+ self.assertSequenceEqual(
+ NullableIntegerArrayModel.objects.filter(field__contains=inner_qs[:1]),
+ self.objs[2:3],
+ )
+ inner_qs = IntegerArrayModel.objects.filter(field__contains=OuterRef("field"))
+ self.assertSequenceEqual(
+ NullableIntegerArrayModel.objects.filter(Exists(inner_qs)),
+ self.objs[1:3],
+ )
+
+ def test_contains_including_expression(self):
+ self.assertSequenceEqual(
+ NullableIntegerArrayModel.objects.filter(
+ field__contains=[2, Value(6) / Value(2)],
+ ),
+ self.objs[2:3],
+ )
+
+ def test_icontains(self):
+ # Using the __icontains lookup with ArrayField is inefficient.
+ instance = CharArrayModel.objects.create(field=["FoO"])
+ self.assertSequenceEqual(
+ CharArrayModel.objects.filter(field__icontains="foo"), [instance]
+ )
+
+ def test_contains_charfield(self):
+ # Regression for #22907
+ self.assertSequenceEqual(
+ CharArrayModel.objects.filter(field__contains=["text"]), []
+ )
+
+ def test_contained_by_charfield(self):
+ self.assertSequenceEqual(
+ CharArrayModel.objects.filter(field__contained_by=["text"]), []
+ )
+
+ def test_overlap_charfield(self):
+ self.assertSequenceEqual(
+ CharArrayModel.objects.filter(field__overlap=["text"]), []
+ )
+
+ def test_overlap_charfield_including_expression(self):
+ obj_1 = CharArrayModel.objects.create(field=["TEXT", "lower text"])
+ obj_2 = CharArrayModel.objects.create(field=["lower text", "TEXT"])
+ CharArrayModel.objects.create(field=["lower text", "text"])
+ self.assertSequenceEqual(
+ CharArrayModel.objects.filter(
+ field__overlap=[
+ Upper(Value("text")),
+ "other",
+ ]
+ ),
+ [obj_1, obj_2],
+ )
+
+ def test_overlap_values(self):
+ qs = NullableIntegerArrayModel.objects.filter(order__lt=3)
+ self.assertCountEqual(
+ NullableIntegerArrayModel.objects.filter(
+ field__overlap=qs.values_list("field"),
+ ),
+ self.objs[:3],
+ )
+ self.assertCountEqual(
+ NullableIntegerArrayModel.objects.filter(
+ field__overlap=qs.values("field"),
+ ),
+ self.objs[:3],
+ )
+
+ def test_lookups_autofield_array(self):
+ qs = (
+ NullableIntegerArrayModel.objects.filter(
+ field__0__isnull=False,
+ )
+ .values("field__0")
+ .annotate(
+ arrayagg=ArrayAgg("id"),
+ )
+ .order_by("field__0")
+ )
+ tests = (
+ ("contained_by", [self.objs[1].pk, self.objs[2].pk, 0], [2]),
+ ("contains", [self.objs[2].pk], [2]),
+ ("exact", [self.objs[3].pk], [20]),
+ ("overlap", [self.objs[1].pk, self.objs[3].pk], [2, 20]),
+ )
+ for lookup, value, expected in tests:
+ with self.subTest(lookup=lookup):
+ self.assertSequenceEqual(
+ qs.filter(
+ **{"arrayagg__" + lookup: value},
+ ).values_list("field__0", flat=True),
+ expected,
+ )
+
+ @skipUnlessDBFeature("allows_group_by_select_index")
+ def test_group_by_order_by_select_index(self):
+ with self.assertNumQueries(1) as ctx:
+ self.assertSequenceEqual(
+ NullableIntegerArrayModel.objects.filter(
+ field__0__isnull=False,
+ )
+ .values("field__0")
+ .annotate(arrayagg=ArrayAgg("id"))
+ .order_by("field__0"),
+ [
+ {"field__0": 1, "arrayagg": [self.objs[0].pk]},
+ {"field__0": 2, "arrayagg": [self.objs[1].pk, self.objs[2].pk]},
+ {"field__0": 20, "arrayagg": [self.objs[3].pk]},
+ ],
+ )
+ sql = ctx[0]["sql"]
+ self.assertIn("GROUP BY 2", sql)
+ self.assertIn("ORDER BY 2", sql)
+
+ def test_index(self):
+ self.assertSequenceEqual(
+ NullableIntegerArrayModel.objects.filter(field__0=2), self.objs[1:3]
+ )
+
+ def test_index_chained(self):
+ self.assertSequenceEqual(
+ NullableIntegerArrayModel.objects.filter(field__0__lt=3), self.objs[0:3]
+ )
+
+ def test_index_nested(self):
+ instance = NestedIntegerArrayModel.objects.create(field=[[1, 2], [3, 4]])
+ self.assertSequenceEqual(
+ NestedIntegerArrayModel.objects.filter(field__0__0=1), [instance]
+ )
+
+ @unittest.expectedFailure
+ def test_index_used_on_nested_data(self):
+ instance = NestedIntegerArrayModel.objects.create(field=[[1, 2], [3, 4]])
+ self.assertSequenceEqual(
+ NestedIntegerArrayModel.objects.filter(field__0=[1, 2]), [instance]
+ )
+
+ def test_index_transform_expression(self):
+ expr = RawSQL("string_to_array(%s, ';')", ["1;2"])
+ self.assertSequenceEqual(
+ NullableIntegerArrayModel.objects.filter(
+ field__0=Cast(
+ IndexTransform(1, models.IntegerField, expr),
+ output_field=models.IntegerField(),
+ ),
+ ),
+ self.objs[:1],
+ )
+
+ def test_index_annotation(self):
+ qs = NullableIntegerArrayModel.objects.annotate(second=models.F("field__1"))
+ self.assertCountEqual(
+ qs.values_list("second", flat=True),
+ [None, None, None, 3, 30],
+ )
+
+ def test_overlap(self):
+ self.assertSequenceEqual(
+ NullableIntegerArrayModel.objects.filter(field__overlap=[1, 2]),
+ self.objs[0:3],
+ )
+
+ def test_len(self):
+ self.assertSequenceEqual(
+ NullableIntegerArrayModel.objects.filter(field__len__lte=2), self.objs[0:3]
+ )
+
+ def test_len_empty_array(self):
+ obj = NullableIntegerArrayModel.objects.create(field=[])
+ self.assertSequenceEqual(
+ NullableIntegerArrayModel.objects.filter(field__len=0), [obj]
+ )
+
+ def test_slice(self):
+ self.assertSequenceEqual(
+ NullableIntegerArrayModel.objects.filter(field__0_1=[2]), self.objs[1:3]
+ )
+
+ self.assertSequenceEqual(
+ NullableIntegerArrayModel.objects.filter(field__0_2=[2, 3]), self.objs[2:3]
+ )
+
+ def test_order_by_slice(self):
+ more_objs = (
+ NullableIntegerArrayModel.objects.create(field=[1, 637]),
+ NullableIntegerArrayModel.objects.create(field=[2, 1]),
+ NullableIntegerArrayModel.objects.create(field=[3, -98123]),
+ NullableIntegerArrayModel.objects.create(field=[4, 2]),
+ )
+ self.assertSequenceEqual(
+ NullableIntegerArrayModel.objects.order_by("field__1"),
+ [
+ more_objs[2],
+ more_objs[1],
+ more_objs[3],
+ self.objs[2],
+ self.objs[3],
+ more_objs[0],
+ self.objs[4],
+ self.objs[1],
+ self.objs[0],
+ ],
+ )
+
+ @unittest.expectedFailure
+ def test_slice_nested(self):
+ instance = NestedIntegerArrayModel.objects.create(field=[[1, 2], [3, 4]])
+ self.assertSequenceEqual(
+ NestedIntegerArrayModel.objects.filter(field__0__0_1=[1]), [instance]
+ )
+
+ def test_slice_transform_expression(self):
+ expr = RawSQL("string_to_array(%s, ';')", ["9;2;3"])
+ self.assertSequenceEqual(
+ NullableIntegerArrayModel.objects.filter(
+ field__0_2=SliceTransform(2, 3, expr)
+ ),
+ self.objs[2:3],
+ )
+
+ def test_slice_annotation(self):
+ qs = NullableIntegerArrayModel.objects.annotate(
+ first_two=models.F("field__0_2"),
+ )
+ self.assertCountEqual(
+ qs.values_list("first_two", flat=True),
+ [None, [1], [2], [2, 3], [20, 30]],
+ )
+
+ def test_usage_in_subquery(self):
+ self.assertSequenceEqual(
+ NullableIntegerArrayModel.objects.filter(
+ id__in=NullableIntegerArrayModel.objects.filter(field__len=3)
+ ),
+ [self.objs[3]],
+ )
+
+ def test_enum_lookup(self):
+ class TestEnum(enum.Enum):
+ VALUE_1 = "value_1"
+
+ instance = ArrayEnumModel.objects.create(array_of_enums=[TestEnum.VALUE_1])
+ self.assertSequenceEqual(
+ ArrayEnumModel.objects.filter(array_of_enums__contains=[TestEnum.VALUE_1]),
+ [instance],
+ )
+
+ def test_unsupported_lookup(self):
+ msg = (
+ "Unsupported lookup '0_bar' for ArrayField or join on the field not "
+ "permitted."
+ )
+ with self.assertRaisesMessage(FieldError, msg):
+ list(NullableIntegerArrayModel.objects.filter(field__0_bar=[2]))
+
+ msg = (
+ "Unsupported lookup '0bar' for ArrayField or join on the field not "
+ "permitted."
+ )
+ with self.assertRaisesMessage(FieldError, msg):
+ list(NullableIntegerArrayModel.objects.filter(field__0bar=[2]))
+
+ def test_grouping_by_annotations_with_array_field_param(self):
+ value = models.Value([1], output_field=ArrayField(models.IntegerField()))
+ self.assertEqual(
+ NullableIntegerArrayModel.objects.annotate(
+ array_length=models.Func(
+ value,
+ 1,
+ function="ARRAY_LENGTH",
+ output_field=models.IntegerField(),
+ ),
+ )
+ .values("array_length")
+ .annotate(
+ count=models.Count("pk"),
+ )
+ .get()["array_length"],
+ 1,
+ )
+
+ def test_filter_by_array_subquery(self):
+ inner_qs = NullableIntegerArrayModel.objects.filter(
+ field__len=models.OuterRef("field__len"),
+ ).values("field")
+ self.assertSequenceEqual(
+ NullableIntegerArrayModel.objects.alias(
+ same_sized_fields=ArraySubquery(inner_qs),
+ ).filter(same_sized_fields__len__gt=1),
+ self.objs[0:2],
+ )
+
+ def test_annotated_array_subquery(self):
+ inner_qs = NullableIntegerArrayModel.objects.exclude(
+ pk=models.OuterRef("pk")
+ ).values("order")
+ self.assertSequenceEqual(
+ NullableIntegerArrayModel.objects.annotate(
+ sibling_ids=ArraySubquery(inner_qs),
+ )
+ .get(order=1)
+ .sibling_ids,
+ [2, 3, 4, 5],
+ )
+
+ def test_group_by_with_annotated_array_subquery(self):
+ inner_qs = NullableIntegerArrayModel.objects.exclude(
+ pk=models.OuterRef("pk")
+ ).values("order")
+ self.assertSequenceEqual(
+ NullableIntegerArrayModel.objects.annotate(
+ sibling_ids=ArraySubquery(inner_qs),
+ sibling_count=models.Max("sibling_ids__len"),
+ ).values_list("sibling_count", flat=True),
+ [len(self.objs) - 1] * len(self.objs),
+ )
+
+ def test_annotated_ordered_array_subquery(self):
+ inner_qs = NullableIntegerArrayModel.objects.order_by("-order").values("order")
+ self.assertSequenceEqual(
+ NullableIntegerArrayModel.objects.annotate(
+ ids=ArraySubquery(inner_qs),
+ )
+ .first()
+ .ids,
+ [5, 4, 3, 2, 1],
+ )
+
+ def test_annotated_array_subquery_with_json_objects(self):
+ inner_qs = NullableIntegerArrayModel.objects.exclude(
+ pk=models.OuterRef("pk")
+ ).values(json=JSONObject(order="order", field="field"))
+ siblings_json = (
+ NullableIntegerArrayModel.objects.annotate(
+ siblings_json=ArraySubquery(inner_qs),
+ )
+ .values_list("siblings_json", flat=True)
+ .get(order=1)
+ )
+ self.assertSequenceEqual(
+ siblings_json,
+ [
+ {"field": [2], "order": 2},
+ {"field": [2, 3], "order": 3},
+ {"field": [20, 30, 40], "order": 4},
+ {"field": None, "order": 5},
+ ],
+ )
+
+
+class TestDateTimeExactQuerying(PostgreSQLTestCase):
+ @classmethod
+ def setUpTestData(cls):
+ now = timezone.now()
+ cls.datetimes = [now]
+ cls.dates = [now.date()]
+ cls.times = [now.time()]
+ cls.objs = [
+ DateTimeArrayModel.objects.create(
+ datetimes=cls.datetimes, dates=cls.dates, times=cls.times
+ ),
+ ]
+
+ def test_exact_datetimes(self):
+ self.assertSequenceEqual(
+ DateTimeArrayModel.objects.filter(datetimes=self.datetimes), self.objs
+ )
+
+ def test_exact_dates(self):
+ self.assertSequenceEqual(
+ DateTimeArrayModel.objects.filter(dates=self.dates), self.objs
+ )
+
+ def test_exact_times(self):
+ self.assertSequenceEqual(
+ DateTimeArrayModel.objects.filter(times=self.times), self.objs
+ )
+
+
+class TestOtherTypesExactQuerying(PostgreSQLTestCase):
+ @classmethod
+ def setUpTestData(cls):
+ cls.ips = ["192.168.0.1", "::1"]
+ cls.uuids = [uuid.uuid4()]
+ cls.decimals = [decimal.Decimal(1.25), 1.75]
+ cls.tags = [Tag(1), Tag(2), Tag(3)]
+ cls.objs = [
+ OtherTypesArrayModel.objects.create(
+ ips=cls.ips,
+ uuids=cls.uuids,
+ decimals=cls.decimals,
+ tags=cls.tags,
+ )
+ ]
+
+ def test_exact_ip_addresses(self):
+ self.assertSequenceEqual(
+ OtherTypesArrayModel.objects.filter(ips=self.ips), self.objs
+ )
+
+ def test_exact_uuids(self):
+ self.assertSequenceEqual(
+ OtherTypesArrayModel.objects.filter(uuids=self.uuids), self.objs
+ )
+
+ def test_exact_decimals(self):
+ self.assertSequenceEqual(
+ OtherTypesArrayModel.objects.filter(decimals=self.decimals), self.objs
+ )
+
+ def test_exact_tags(self):
+ self.assertSequenceEqual(
+ OtherTypesArrayModel.objects.filter(tags=self.tags), self.objs
+ )
+
+
+@isolate_apps("postgres_tests")
+class TestChecks(PostgreSQLSimpleTestCase):
+ def test_field_checks(self):
+ class MyModel(PostgreSQLModel):
+ field = ArrayField(models.CharField(max_length=-1))
+
+ model = MyModel()
+ errors = model.check()
+ self.assertEqual(len(errors), 1)
+ # The inner CharField has a non-positive max_length.
+ self.assertEqual(errors[0].id, "postgres.E001")
+ self.assertIn("max_length", errors[0].msg)
+
+ def test_invalid_base_fields(self):
+ class MyModel(PostgreSQLModel):
+ field = ArrayField(
+ models.ManyToManyField("postgres_tests.IntegerArrayModel")
+ )
+
+ model = MyModel()
+ errors = model.check()
+ self.assertEqual(len(errors), 1)
+ self.assertEqual(errors[0].id, "postgres.E002")
+
+ def test_invalid_default(self):
+ class MyModel(PostgreSQLModel):
+ field = ArrayField(models.IntegerField(), default=[])
+
+ model = MyModel()
+ self.assertEqual(
+ model.check(),
+ [
+ checks.Warning(
+ msg=(
+ "ArrayField default should be a callable instead of an "
+ "instance so that it's not shared between all field "
+ "instances."
+ ),
+ hint="Use a callable instead, e.g., use `list` instead of `[]`.",
+ obj=MyModel._meta.get_field("field"),
+ id="fields.E010",
+ )
+ ],
+ )
+
+ def test_valid_default(self):
+ class MyModel(PostgreSQLModel):
+ field = ArrayField(models.IntegerField(), default=list)
+
+ model = MyModel()
+ self.assertEqual(model.check(), [])
+
+ def test_valid_default_none(self):
+ class MyModel(PostgreSQLModel):
+ field = ArrayField(models.IntegerField(), default=None)
+
+ model = MyModel()
+ self.assertEqual(model.check(), [])
+
+ def test_nested_field_checks(self):
+ """
+ Nested ArrayFields are permitted.
+ """
+
+ class MyModel(PostgreSQLModel):
+ field = ArrayField(ArrayField(models.CharField(max_length=-1)))
+
+ model = MyModel()
+ errors = model.check()
+ self.assertEqual(len(errors), 1)
+ # The inner CharField has a non-positive max_length.
+ self.assertEqual(errors[0].id, "postgres.E001")
+ self.assertIn("max_length", errors[0].msg)
+
+ def test_choices_tuple_list(self):
+ class MyModel(PostgreSQLModel):
+ field = ArrayField(
+ models.CharField(max_length=16),
+ choices=[
+ [
+ "Media",
+ [(["vinyl", "cd"], "Audio"), (("vhs", "dvd"), "Video")],
+ ],
+ (["mp3", "mp4"], "Digital"),
+ ],
+ )
+
+ self.assertEqual(MyModel._meta.get_field("field").check(), [])
+
+
+@unittest.skipUnless(connection.vendor == "postgresql", "PostgreSQL specific tests")
+class TestMigrations(TransactionTestCase):
+ available_apps = ["postgres_tests"]
+
+ def test_deconstruct(self):
+ field = ArrayField(models.IntegerField())
+ name, path, args, kwargs = field.deconstruct()
+ new = ArrayField(*args, **kwargs)
+ self.assertEqual(type(new.base_field), type(field.base_field))
+ self.assertIsNot(new.base_field, field.base_field)
+
+ def test_deconstruct_with_size(self):
+ field = ArrayField(models.IntegerField(), size=3)
+ name, path, args, kwargs = field.deconstruct()
+ new = ArrayField(*args, **kwargs)
+ self.assertEqual(new.size, field.size)
+
+ def test_deconstruct_args(self):
+ field = ArrayField(models.CharField(max_length=20))
+ name, path, args, kwargs = field.deconstruct()
+ new = ArrayField(*args, **kwargs)
+ self.assertEqual(new.base_field.max_length, field.base_field.max_length)
+
+ def test_subclass_deconstruct(self):
+ field = ArrayField(models.IntegerField())
+ name, path, args, kwargs = field.deconstruct()
+ self.assertEqual(path, "django.contrib.postgres.fields.ArrayField")
+
+ field = ArrayFieldSubclass()
+ name, path, args, kwargs = field.deconstruct()
+ self.assertEqual(path, "postgres_tests.models.ArrayFieldSubclass")
+
+ @override_settings(
+ MIGRATION_MODULES={
+ "postgres_tests": "postgres_tests.array_default_migrations",
+ }
+ )
+ def test_adding_field_with_default(self):
+ # See #22962
+ table_name = "postgres_tests_integerarraydefaultmodel"
+ with connection.cursor() as cursor:
+ self.assertNotIn(table_name, connection.introspection.table_names(cursor))
+ call_command("migrate", "postgres_tests", verbosity=0)
+ with connection.cursor() as cursor:
+ self.assertIn(table_name, connection.introspection.table_names(cursor))
+ call_command("migrate", "postgres_tests", "zero", verbosity=0)
+ with connection.cursor() as cursor:
+ self.assertNotIn(table_name, connection.introspection.table_names(cursor))
+
+ @override_settings(
+ MIGRATION_MODULES={
+ "postgres_tests": "postgres_tests.array_index_migrations",
+ }
+ )
+ def test_adding_arrayfield_with_index(self):
+ """
+ ArrayField shouldn't have varchar_patterns_ops or text_patterns_ops indexes.
+ """
+ table_name = "postgres_tests_chartextarrayindexmodel"
+ call_command("migrate", "postgres_tests", verbosity=0)
+ with connection.cursor() as cursor:
+ like_constraint_columns_list = [
+ v["columns"]
+ for k, v in list(
+ connection.introspection.get_constraints(cursor, table_name).items()
+ )
+ if k.endswith("_like")
+ ]
+ # Only the CharField should have a LIKE index.
+ self.assertEqual(like_constraint_columns_list, [["char2"]])
+ # All fields should have regular indexes.
+ with connection.cursor() as cursor:
+ indexes = [
+ c["columns"][0]
+ for c in connection.introspection.get_constraints(
+ cursor, table_name
+ ).values()
+ if c["index"] and len(c["columns"]) == 1
+ ]
+ self.assertIn("char", indexes)
+ self.assertIn("char2", indexes)
+ self.assertIn("text", indexes)
+ call_command("migrate", "postgres_tests", "zero", verbosity=0)
+ with connection.cursor() as cursor:
+ self.assertNotIn(table_name, connection.introspection.table_names(cursor))
+
+
+class TestSerialization(PostgreSQLSimpleTestCase):
+ test_data = (
+ '[{"fields": {"field": "[\\"1\\", \\"2\\", null]"}, '
+ '"model": "postgres_tests.integerarraymodel", "pk": null}]'
+ )
+
+ def test_dumping(self):
+ instance = IntegerArrayModel(field=[1, 2, None])
+ data = serializers.serialize("json", [instance])
+ self.assertEqual(json.loads(data), json.loads(self.test_data))
+
+ def test_loading(self):
+ instance = list(serializers.deserialize("json", self.test_data))[0].object
+ self.assertEqual(instance.field, [1, 2, None])
+
+
+class TestValidation(PostgreSQLSimpleTestCase):
+ def test_unbounded(self):
+ field = ArrayField(models.IntegerField())
+ with self.assertRaises(exceptions.ValidationError) as cm:
+ field.clean([1, None], None)
+ self.assertEqual(cm.exception.code, "item_invalid")
+ self.assertEqual(
+ cm.exception.message % cm.exception.params,
+ "Item 2 in the array did not validate: This field cannot be null.",
+ )
+
+ def test_blank_true(self):
+ field = ArrayField(models.IntegerField(blank=True, null=True))
+ # This should not raise a validation error
+ field.clean([1, None], None)
+
+ def test_with_size(self):
+ field = ArrayField(models.IntegerField(), size=3)
+ field.clean([1, 2, 3], None)
+ with self.assertRaises(exceptions.ValidationError) as cm:
+ field.clean([1, 2, 3, 4], None)
+ self.assertEqual(
+ cm.exception.messages[0],
+ "List contains 4 items, it should contain no more than 3.",
+ )
+
+ def test_with_size_singular(self):
+ field = ArrayField(models.IntegerField(), size=1)
+ field.clean([1], None)
+ msg = "List contains 2 items, it should contain no more than 1."
+ with self.assertRaisesMessage(exceptions.ValidationError, msg):
+ field.clean([1, 2], None)
+
+ def test_nested_array_mismatch(self):
+ field = ArrayField(ArrayField(models.IntegerField()))
+ field.clean([[1, 2], [3, 4]], None)
+ with self.assertRaises(exceptions.ValidationError) as cm:
+ field.clean([[1, 2], [3, 4, 5]], None)
+ self.assertEqual(cm.exception.code, "nested_array_mismatch")
+ self.assertEqual(
+ cm.exception.messages[0], "Nested arrays must have the same length."
+ )
+
+ def test_with_base_field_error_params(self):
+ field = ArrayField(models.CharField(max_length=2))
+ with self.assertRaises(exceptions.ValidationError) as cm:
+ field.clean(["abc"], None)
+ self.assertEqual(len(cm.exception.error_list), 1)
+ exception = cm.exception.error_list[0]
+ self.assertEqual(
+ exception.message,
+ "Item 1 in the array did not validate: Ensure this value has at most 2 "
+ "characters (it has 3).",
+ )
+ self.assertEqual(exception.code, "item_invalid")
+ self.assertEqual(
+ exception.params,
+ {"nth": 1, "value": "abc", "limit_value": 2, "show_value": 3},
+ )
+
+ def test_with_validators(self):
+ field = ArrayField(
+ models.IntegerField(validators=[validators.MinValueValidator(1)])
+ )
+ field.clean([1, 2], None)
+ with self.assertRaises(exceptions.ValidationError) as cm:
+ field.clean([0], None)
+ self.assertEqual(len(cm.exception.error_list), 1)
+ exception = cm.exception.error_list[0]
+ self.assertEqual(
+ exception.message,
+ "Item 1 in the array did not validate: Ensure this value is greater than "
+ "or equal to 1.",
+ )
+ self.assertEqual(exception.code, "item_invalid")
+ self.assertEqual(
+ exception.params, {"nth": 1, "value": 0, "limit_value": 1, "show_value": 0}
+ )
+
+
+class TestSimpleFormField(PostgreSQLSimpleTestCase):
+ def test_valid(self):
+ field = SimpleArrayField(forms.CharField())
+ value = field.clean("a,b,c")
+ self.assertEqual(value, ["a", "b", "c"])
+
+ def test_to_python_fail(self):
+ field = SimpleArrayField(forms.IntegerField())
+ with self.assertRaises(exceptions.ValidationError) as cm:
+ field.clean("a,b,9")
+ self.assertEqual(
+ cm.exception.messages[0],
+ "Item 1 in the array did not validate: Enter a whole number.",
+ )
+
+ def test_validate_fail(self):
+ field = SimpleArrayField(forms.CharField(required=True))
+ with self.assertRaises(exceptions.ValidationError) as cm:
+ field.clean("a,b,")
+ self.assertEqual(
+ cm.exception.messages[0],
+ "Item 3 in the array did not validate: This field is required.",
+ )
+
+ def test_validate_fail_base_field_error_params(self):
+ field = SimpleArrayField(forms.CharField(max_length=2))
+ with self.assertRaises(exceptions.ValidationError) as cm:
+ field.clean("abc,c,defg")
+ errors = cm.exception.error_list
+ self.assertEqual(len(errors), 2)
+ first_error = errors[0]
+ self.assertEqual(
+ first_error.message,
+ "Item 1 in the array did not validate: Ensure this value has at most 2 "
+ "characters (it has 3).",
+ )
+ self.assertEqual(first_error.code, "item_invalid")
+ self.assertEqual(
+ first_error.params,
+ {"nth": 1, "value": "abc", "limit_value": 2, "show_value": 3},
+ )
+ second_error = errors[1]
+ self.assertEqual(
+ second_error.message,
+ "Item 3 in the array did not validate: Ensure this value has at most 2 "
+ "characters (it has 4).",
+ )
+ self.assertEqual(second_error.code, "item_invalid")
+ self.assertEqual(
+ second_error.params,
+ {"nth": 3, "value": "defg", "limit_value": 2, "show_value": 4},
+ )
+
+ def test_validators_fail(self):
+ field = SimpleArrayField(forms.RegexField("[a-e]{2}"))
+ with self.assertRaises(exceptions.ValidationError) as cm:
+ field.clean("a,bc,de")
+ self.assertEqual(
+ cm.exception.messages[0],
+ "Item 1 in the array did not validate: Enter a valid value.",
+ )
+
+ def test_delimiter(self):
+ field = SimpleArrayField(forms.CharField(), delimiter="|")
+ value = field.clean("a|b|c")
+ self.assertEqual(value, ["a", "b", "c"])
+
+ def test_delimiter_with_nesting(self):
+ field = SimpleArrayField(SimpleArrayField(forms.CharField()), delimiter="|")
+ value = field.clean("a,b|c,d")
+ self.assertEqual(value, [["a", "b"], ["c", "d"]])
+
+ def test_prepare_value(self):
+ field = SimpleArrayField(forms.CharField())
+ value = field.prepare_value(["a", "b", "c"])
+ self.assertEqual(value, "a,b,c")
+
+ def test_max_length(self):
+ field = SimpleArrayField(forms.CharField(), max_length=2)
+ with self.assertRaises(exceptions.ValidationError) as cm:
+ field.clean("a,b,c")
+ self.assertEqual(
+ cm.exception.messages[0],
+ "List contains 3 items, it should contain no more than 2.",
+ )
+
+ def test_min_length(self):
+ field = SimpleArrayField(forms.CharField(), min_length=4)
+ with self.assertRaises(exceptions.ValidationError) as cm:
+ field.clean("a,b,c")
+ self.assertEqual(
+ cm.exception.messages[0],
+ "List contains 3 items, it should contain no fewer than 4.",
+ )
+
+ def test_min_length_singular(self):
+ field = SimpleArrayField(forms.IntegerField(), min_length=2)
+ field.clean([1, 2])
+ msg = "List contains 1 item, it should contain no fewer than 2."
+ with self.assertRaisesMessage(exceptions.ValidationError, msg):
+ field.clean([1])
+
+ def test_required(self):
+ field = SimpleArrayField(forms.CharField(), required=True)
+ with self.assertRaises(exceptions.ValidationError) as cm:
+ field.clean("")
+ self.assertEqual(cm.exception.messages[0], "This field is required.")
+
+ def test_model_field_formfield(self):
+ model_field = ArrayField(models.CharField(max_length=27))
+ form_field = model_field.formfield()
+ self.assertIsInstance(form_field, SimpleArrayField)
+ self.assertIsInstance(form_field.base_field, forms.CharField)
+ self.assertEqual(form_field.base_field.max_length, 27)
+
+ def test_model_field_formfield_size(self):
+ model_field = ArrayField(models.CharField(max_length=27), size=4)
+ form_field = model_field.formfield()
+ self.assertIsInstance(form_field, SimpleArrayField)
+ self.assertEqual(form_field.max_length, 4)
+
+ def test_model_field_choices(self):
+ model_field = ArrayField(models.IntegerField(choices=((1, "A"), (2, "B"))))
+ form_field = model_field.formfield()
+ self.assertEqual(form_field.clean("1,2"), [1, 2])
+
+ def test_already_converted_value(self):
+ field = SimpleArrayField(forms.CharField())
+ vals = ["a", "b", "c"]
+ self.assertEqual(field.clean(vals), vals)
+
+ def test_has_changed(self):
+ field = SimpleArrayField(forms.IntegerField())
+ self.assertIs(field.has_changed([1, 2], [1, 2]), False)
+ self.assertIs(field.has_changed([1, 2], "1,2"), False)
+ self.assertIs(field.has_changed([1, 2], "1,2,3"), True)
+ self.assertIs(field.has_changed([1, 2], "a,b"), True)
+
+ def test_has_changed_empty(self):
+ field = SimpleArrayField(forms.CharField())
+ self.assertIs(field.has_changed(None, None), False)
+ self.assertIs(field.has_changed(None, ""), False)
+ self.assertIs(field.has_changed(None, []), False)
+ self.assertIs(field.has_changed([], None), False)
+ self.assertIs(field.has_changed([], ""), False)
+
+
+class TestSplitFormField(PostgreSQLSimpleTestCase):
+ def test_valid(self):
+ class SplitForm(forms.Form):
+ array = SplitArrayField(forms.CharField(), size=3)
+
+ data = {"array_0": "a", "array_1": "b", "array_2": "c"}
+ form = SplitForm(data)
+ self.assertTrue(form.is_valid())
+ self.assertEqual(form.cleaned_data, {"array": ["a", "b", "c"]})
+
+ def test_required(self):
+ class SplitForm(forms.Form):
+ array = SplitArrayField(forms.CharField(), required=True, size=3)
+
+ data = {"array_0": "", "array_1": "", "array_2": ""}
+ form = SplitForm(data)
+ self.assertFalse(form.is_valid())
+ self.assertEqual(form.errors, {"array": ["This field is required."]})
+
+ def test_remove_trailing_nulls(self):
+ class SplitForm(forms.Form):
+ array = SplitArrayField(
+ forms.CharField(required=False), size=5, remove_trailing_nulls=True
+ )
+
+ data = {
+ "array_0": "a",
+ "array_1": "",
+ "array_2": "b",
+ "array_3": "",
+ "array_4": "",
+ }
+ form = SplitForm(data)
+ self.assertTrue(form.is_valid(), form.errors)
+ self.assertEqual(form.cleaned_data, {"array": ["a", "", "b"]})
+
+ def test_remove_trailing_nulls_not_required(self):
+ class SplitForm(forms.Form):
+ array = SplitArrayField(
+ forms.CharField(required=False),
+ size=2,
+ remove_trailing_nulls=True,
+ required=False,
+ )
+
+ data = {"array_0": "", "array_1": ""}
+ form = SplitForm(data)
+ self.assertTrue(form.is_valid())
+ self.assertEqual(form.cleaned_data, {"array": []})
+
+ def test_required_field(self):
+ class SplitForm(forms.Form):
+ array = SplitArrayField(forms.CharField(), size=3)
+
+ data = {"array_0": "a", "array_1": "b", "array_2": ""}
+ form = SplitForm(data)
+ self.assertFalse(form.is_valid())
+ self.assertEqual(
+ form.errors,
+ {
+ "array": [
+ "Item 3 in the array did not validate: This field is required."
+ ]
+ },
+ )
+
+ def test_invalid_integer(self):
+ msg = (
+ "Item 2 in the array did not validate: Ensure this value is less than or "
+ "equal to 100."
+ )
+ with self.assertRaisesMessage(exceptions.ValidationError, msg):
+ SplitArrayField(forms.IntegerField(max_value=100), size=2).clean([0, 101])
+
+ def test_rendering(self):
+ class SplitForm(forms.Form):
+ array = SplitArrayField(forms.CharField(), size=3)
+
+ self.assertHTMLEqual(
+ str(SplitForm()),
+ """
+
+
+
+
+
+
+ """,
+ )
+
+ def test_invalid_char_length(self):
+ field = SplitArrayField(forms.CharField(max_length=2), size=3)
+ with self.assertRaises(exceptions.ValidationError) as cm:
+ field.clean(["abc", "c", "defg"])
+ self.assertEqual(
+ cm.exception.messages,
+ [
+ "Item 1 in the array did not validate: Ensure this value has at most 2 "
+ "characters (it has 3).",
+ "Item 3 in the array did not validate: Ensure this value has at most 2 "
+ "characters (it has 4).",
+ ],
+ )
+
+ def test_splitarraywidget_value_omitted_from_data(self):
+ class Form(forms.ModelForm):
+ field = SplitArrayField(forms.IntegerField(), required=False, size=2)
+
+ class Meta:
+ model = IntegerArrayModel
+ fields = ("field",)
+
+ form = Form({"field_0": "1", "field_1": "2"})
+ self.assertEqual(form.errors, {})
+ obj = form.save(commit=False)
+ self.assertEqual(obj.field, [1, 2])
+
+ def test_splitarrayfield_has_changed(self):
+ class Form(forms.ModelForm):
+ field = SplitArrayField(forms.IntegerField(), required=False, size=2)
+
+ class Meta:
+ model = IntegerArrayModel
+ fields = ("field",)
+
+ tests = [
+ ({}, {"field_0": "", "field_1": ""}, True),
+ ({"field": None}, {"field_0": "", "field_1": ""}, True),
+ ({"field": [1]}, {"field_0": "", "field_1": ""}, True),
+ ({"field": [1]}, {"field_0": "1", "field_1": "0"}, True),
+ ({"field": [1, 2]}, {"field_0": "1", "field_1": "2"}, False),
+ ({"field": [1, 2]}, {"field_0": "a", "field_1": "b"}, True),
+ ]
+ for initial, data, expected_result in tests:
+ with self.subTest(initial=initial, data=data):
+ obj = IntegerArrayModel(**initial)
+ form = Form(data, instance=obj)
+ self.assertIs(form.has_changed(), expected_result)
+
+ def test_splitarrayfield_remove_trailing_nulls_has_changed(self):
+ class Form(forms.ModelForm):
+ field = SplitArrayField(
+ forms.IntegerField(), required=False, size=2, remove_trailing_nulls=True
+ )
+
+ class Meta:
+ model = IntegerArrayModel
+ fields = ("field",)
+
+ tests = [
+ ({}, {"field_0": "", "field_1": ""}, False),
+ ({"field": None}, {"field_0": "", "field_1": ""}, False),
+ ({"field": []}, {"field_0": "", "field_1": ""}, False),
+ ({"field": [1]}, {"field_0": "1", "field_1": ""}, False),
+ ]
+ for initial, data, expected_result in tests:
+ with self.subTest(initial=initial, data=data):
+ obj = IntegerArrayModel(**initial)
+ form = Form(data, instance=obj)
+ self.assertIs(form.has_changed(), expected_result)
+
+
+class TestSplitFormWidget(PostgreSQLWidgetTestCase):
+ def test_get_context(self):
+ self.assertEqual(
+ SplitArrayWidget(forms.TextInput(), size=2).get_context(
+ "name", ["val1", "val2"]
+ ),
+ {
+ "widget": {
+ "name": "name",
+ "is_hidden": False,
+ "required": False,
+ "value": "['val1', 'val2']",
+ "attrs": {},
+ "template_name": "postgres/widgets/split_array.html",
+ "subwidgets": [
+ {
+ "name": "name_0",
+ "is_hidden": False,
+ "required": False,
+ "value": "val1",
+ "attrs": {},
+ "template_name": "django/forms/widgets/text.html",
+ "type": "text",
+ },
+ {
+ "name": "name_1",
+ "is_hidden": False,
+ "required": False,
+ "value": "val2",
+ "attrs": {},
+ "template_name": "django/forms/widgets/text.html",
+ "type": "text",
+ },
+ ],
+ }
+ },
+ )
+
+ def test_checkbox_get_context_attrs(self):
+ context = SplitArrayWidget(
+ forms.CheckboxInput(),
+ size=2,
+ ).get_context("name", [True, False])
+ self.assertEqual(context["widget"]["value"], "[True, False]")
+ self.assertEqual(
+ [subwidget["attrs"] for subwidget in context["widget"]["subwidgets"]],
+ [{"checked": True}, {}],
+ )
+
+ def test_render(self):
+ self.check_html(
+ SplitArrayWidget(forms.TextInput(), size=2),
+ "array",
+ None,
+ """
+
+
+ """,
+ )
+
+ def test_render_attrs(self):
+ self.check_html(
+ SplitArrayWidget(forms.TextInput(), size=2),
+ "array",
+ ["val1", "val2"],
+ attrs={"id": "foo"},
+ html=(
+ """
+
+
+ """
+ ),
+ )
+
+ def test_value_omitted_from_data(self):
+ widget = SplitArrayWidget(forms.TextInput(), size=2)
+ self.assertIs(widget.value_omitted_from_data({}, {}, "field"), True)
+ self.assertIs(
+ widget.value_omitted_from_data({"field_0": "value"}, {}, "field"), False
+ )
+ self.assertIs(
+ widget.value_omitted_from_data({"field_1": "value"}, {}, "field"), False
+ )
+ self.assertIs(
+ widget.value_omitted_from_data(
+ {"field_0": "value", "field_1": "value"}, {}, "field"
+ ),
+ False,
+ )
+
+
+class TestAdminUtils(PostgreSQLTestCase):
+ empty_value = "-empty-"
+
+ def test_array_display_for_field(self):
+ array_field = ArrayField(models.IntegerField())
+ display_value = display_for_field(
+ [1, 2],
+ array_field,
+ self.empty_value,
+ )
+ self.assertEqual(display_value, "1, 2")
+
+ def test_array_with_choices_display_for_field(self):
+ array_field = ArrayField(
+ models.IntegerField(),
+ choices=[
+ ([1, 2, 3], "1st choice"),
+ ([1, 2], "2nd choice"),
+ ],
+ )
+
+ display_value = display_for_field(
+ [1, 2],
+ array_field,
+ self.empty_value,
+ )
+ self.assertEqual(display_value, "2nd choice")
+
+ display_value = display_for_field(
+ [99, 99],
+ array_field,
+ self.empty_value,
+ )
+ self.assertEqual(display_value, self.empty_value)
diff --git a/testbed/django__django/tests/postgres_tests/test_bulk_update.py b/testbed/django__django/tests/postgres_tests/test_bulk_update.py
new file mode 100644
index 0000000000000000000000000000000000000000..85dfcedd09f45772f88383042a8fa99953622b22
--- /dev/null
+++ b/testbed/django__django/tests/postgres_tests/test_bulk_update.py
@@ -0,0 +1,46 @@
+from datetime import date
+
+from . import PostgreSQLTestCase
+from .models import (
+ HStoreModel,
+ IntegerArrayModel,
+ NestedIntegerArrayModel,
+ NullableIntegerArrayModel,
+ OtherTypesArrayModel,
+ RangesModel,
+)
+
+try:
+ from django.db.backends.postgresql.psycopg_any import DateRange, NumericRange
+except ImportError:
+ pass # psycopg isn't installed.
+
+
+class BulkSaveTests(PostgreSQLTestCase):
+ def test_bulk_update(self):
+ test_data = [
+ (IntegerArrayModel, "field", [], [1, 2, 3]),
+ (NullableIntegerArrayModel, "field", [1, 2, 3], None),
+ (NestedIntegerArrayModel, "field", [], [[1, 2, 3]]),
+ (HStoreModel, "field", {}, {1: 2}),
+ (RangesModel, "ints", None, NumericRange(lower=1, upper=10)),
+ (
+ RangesModel,
+ "dates",
+ None,
+ DateRange(lower=date.today(), upper=date.today()),
+ ),
+ (OtherTypesArrayModel, "ips", [], ["1.2.3.4"]),
+ (OtherTypesArrayModel, "json", [], [{"a": "b"}]),
+ ]
+ for Model, field, initial, new in test_data:
+ with self.subTest(model=Model, field=field):
+ instances = Model.objects.bulk_create(
+ Model(**{field: initial}) for _ in range(20)
+ )
+ for instance in instances:
+ setattr(instance, field, new)
+ Model.objects.bulk_update(instances, [field])
+ self.assertSequenceEqual(
+ Model.objects.filter(**{field: new}), instances
+ )
diff --git a/testbed/django__django/tests/postgres_tests/test_citext.py b/testbed/django__django/tests/postgres_tests/test_citext.py
new file mode 100644
index 0000000000000000000000000000000000000000..2abb56b39f8a8637a2e90a49f785694c651e4782
--- /dev/null
+++ b/testbed/django__django/tests/postgres_tests/test_citext.py
@@ -0,0 +1,91 @@
+# RemovedInDjango51Warning.
+"""
+The citext PostgreSQL extension supports indexing of case-insensitive text
+strings and thus eliminates the need for operations such as iexact and other
+modifiers to enforce use of an index.
+"""
+from django.db import IntegrityError
+from django.utils.deprecation import RemovedInDjango51Warning
+
+from . import PostgreSQLTestCase
+from .models import CITestModel
+
+
+class CITextTestCase(PostgreSQLTestCase):
+ case_sensitive_lookups = ("contains", "startswith", "endswith", "regex")
+
+ @classmethod
+ def setUpTestData(cls):
+ cls.john = CITestModel.objects.create(
+ name="JoHn",
+ email="joHn@johN.com",
+ description="Average Joe named JoHn",
+ array_field=["JoE", "jOhn"],
+ )
+
+ def test_equal_lowercase(self):
+ """
+ citext removes the need for iexact as the index is case-insensitive.
+ """
+ self.assertEqual(
+ CITestModel.objects.filter(name=self.john.name.lower()).count(), 1
+ )
+ self.assertEqual(
+ CITestModel.objects.filter(email=self.john.email.lower()).count(), 1
+ )
+ self.assertEqual(
+ CITestModel.objects.filter(
+ description=self.john.description.lower()
+ ).count(),
+ 1,
+ )
+
+ def test_fail_citext_primary_key(self):
+ """
+ Creating an entry for a citext field used as a primary key which
+ clashes with an existing value isn't allowed.
+ """
+ with self.assertRaises(IntegrityError):
+ CITestModel.objects.create(name="John")
+
+ def test_array_field(self):
+ instance = CITestModel.objects.get()
+ self.assertEqual(instance.array_field, self.john.array_field)
+ self.assertTrue(
+ CITestModel.objects.filter(array_field__contains=["joe"]).exists()
+ )
+
+ def test_lookups_name_char(self):
+ for lookup in self.case_sensitive_lookups:
+ with self.subTest(lookup=lookup):
+ query = {"name__{}".format(lookup): "john"}
+ self.assertSequenceEqual(
+ CITestModel.objects.filter(**query), [self.john]
+ )
+
+ def test_lookups_description_text(self):
+ for lookup, string in zip(
+ self.case_sensitive_lookups, ("average", "average joe", "john", "Joe.named")
+ ):
+ with self.subTest(lookup=lookup, string=string):
+ query = {"description__{}".format(lookup): string}
+ self.assertSequenceEqual(
+ CITestModel.objects.filter(**query), [self.john]
+ )
+
+ def test_lookups_email(self):
+ for lookup, string in zip(
+ self.case_sensitive_lookups, ("john", "john", "john.com", "john.com")
+ ):
+ with self.subTest(lookup=lookup, string=string):
+ query = {"email__{}".format(lookup): string}
+ self.assertSequenceEqual(
+ CITestModel.objects.filter(**query), [self.john]
+ )
+
+ def test_citext_deprecated(self):
+ from django.contrib.postgres.fields import CIText
+
+ msg = "django.contrib.postgres.fields.CIText mixin is deprecated."
+ with self.assertRaisesMessage(RemovedInDjango51Warning, msg):
+ CIText()
diff --git a/testbed/django__django/tests/postgres_tests/test_constraints.py b/testbed/django__django/tests/postgres_tests/test_constraints.py
new file mode 100644
index 0000000000000000000000000000000000000000..bf47833743058121218e4c36b19690921e752e08
--- /dev/null
+++ b/testbed/django__django/tests/postgres_tests/test_constraints.py
@@ -0,0 +1,1170 @@
+import datetime
+from unittest import mock
+
+from django.contrib.postgres.indexes import OpClass
+from django.core.exceptions import ValidationError
+from django.db import IntegrityError, NotSupportedError, connection, transaction
+from django.db.models import (
+ CheckConstraint,
+ Deferrable,
+ F,
+ Func,
+ IntegerField,
+ Model,
+ Q,
+ UniqueConstraint,
+)
+from django.db.models.fields.json import KeyTextTransform
+from django.db.models.functions import Cast, Left, Lower
+from django.test import skipUnlessDBFeature
+from django.test.utils import isolate_apps
+from django.utils import timezone
+
+from . import PostgreSQLTestCase
+from .models import HotelReservation, IntegerArrayModel, RangesModel, Room, Scene
+
+try:
+ from django.contrib.postgres.constraints import ExclusionConstraint
+ from django.contrib.postgres.fields import (
+ DateTimeRangeField,
+ RangeBoundary,
+ RangeOperators,
+ )
+ from django.db.backends.postgresql.psycopg_any import DateRange, NumericRange
+except ImportError:
+ pass
+
+
+class SchemaTests(PostgreSQLTestCase):
+ 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 get_constraints(self, table):
+ """Get the constraints on the table using a new cursor."""
+ with connection.cursor() as cursor:
+ return connection.introspection.get_constraints(cursor, table)
+
+ def test_check_constraint_range_value(self):
+ constraint_name = "ints_between"
+ self.assertNotIn(
+ constraint_name, self.get_constraints(RangesModel._meta.db_table)
+ )
+ constraint = CheckConstraint(
+ check=Q(ints__contained_by=NumericRange(10, 30)),
+ name=constraint_name,
+ )
+ with connection.schema_editor() as editor:
+ editor.add_constraint(RangesModel, constraint)
+ self.assertIn(constraint_name, self.get_constraints(RangesModel._meta.db_table))
+ with self.assertRaises(IntegrityError), transaction.atomic():
+ RangesModel.objects.create(ints=(20, 50))
+ RangesModel.objects.create(ints=(10, 30))
+
+ def test_check_constraint_array_contains(self):
+ constraint = CheckConstraint(
+ check=Q(field__contains=[1]),
+ name="array_contains",
+ )
+ msg = f"Constraint “{constraint.name}” is violated."
+ with self.assertRaisesMessage(ValidationError, msg):
+ constraint.validate(IntegerArrayModel, IntegerArrayModel())
+ constraint.validate(IntegerArrayModel, IntegerArrayModel(field=[1]))
+
+ def test_check_constraint_array_length(self):
+ constraint = CheckConstraint(
+ check=Q(field__len=1),
+ name="array_length",
+ )
+ msg = f"Constraint “{constraint.name}” is violated."
+ with self.assertRaisesMessage(ValidationError, msg):
+ constraint.validate(IntegerArrayModel, IntegerArrayModel())
+ constraint.validate(IntegerArrayModel, IntegerArrayModel(field=[1]))
+
+ def test_check_constraint_daterange_contains(self):
+ constraint_name = "dates_contains"
+ self.assertNotIn(
+ constraint_name, self.get_constraints(RangesModel._meta.db_table)
+ )
+ constraint = CheckConstraint(
+ check=Q(dates__contains=F("dates_inner")),
+ name=constraint_name,
+ )
+ with connection.schema_editor() as editor:
+ editor.add_constraint(RangesModel, constraint)
+ self.assertIn(constraint_name, self.get_constraints(RangesModel._meta.db_table))
+ date_1 = datetime.date(2016, 1, 1)
+ date_2 = datetime.date(2016, 1, 4)
+ with self.assertRaises(IntegrityError), transaction.atomic():
+ RangesModel.objects.create(
+ dates=(date_1, date_2),
+ dates_inner=(date_1, date_2.replace(day=5)),
+ )
+ RangesModel.objects.create(
+ dates=(date_1, date_2),
+ dates_inner=(date_1, date_2),
+ )
+
+ def test_check_constraint_datetimerange_contains(self):
+ constraint_name = "timestamps_contains"
+ self.assertNotIn(
+ constraint_name, self.get_constraints(RangesModel._meta.db_table)
+ )
+ constraint = CheckConstraint(
+ check=Q(timestamps__contains=F("timestamps_inner")),
+ name=constraint_name,
+ )
+ with connection.schema_editor() as editor:
+ editor.add_constraint(RangesModel, constraint)
+ self.assertIn(constraint_name, self.get_constraints(RangesModel._meta.db_table))
+ datetime_1 = datetime.datetime(2016, 1, 1)
+ datetime_2 = datetime.datetime(2016, 1, 2, 12)
+ with self.assertRaises(IntegrityError), transaction.atomic():
+ RangesModel.objects.create(
+ timestamps=(datetime_1, datetime_2),
+ timestamps_inner=(datetime_1, datetime_2.replace(hour=13)),
+ )
+ RangesModel.objects.create(
+ timestamps=(datetime_1, datetime_2),
+ timestamps_inner=(datetime_1, datetime_2),
+ )
+
+ def test_check_constraint_range_contains(self):
+ constraint = CheckConstraint(
+ check=Q(ints__contains=(1, 5)),
+ name="ints_contains",
+ )
+ msg = f"Constraint “{constraint.name}” is violated."
+ with self.assertRaisesMessage(ValidationError, msg):
+ constraint.validate(RangesModel, RangesModel(ints=(6, 10)))
+
+ def test_check_constraint_range_lower_upper(self):
+ constraint = CheckConstraint(
+ check=Q(ints__startswith__gte=0) & Q(ints__endswith__lte=99),
+ name="ints_range_lower_upper",
+ )
+ msg = f"Constraint “{constraint.name}” is violated."
+ with self.assertRaisesMessage(ValidationError, msg):
+ constraint.validate(RangesModel, RangesModel(ints=(-1, 20)))
+ with self.assertRaisesMessage(ValidationError, msg):
+ constraint.validate(RangesModel, RangesModel(ints=(0, 100)))
+ constraint.validate(RangesModel, RangesModel(ints=(0, 99)))
+
+ def test_check_constraint_range_lower_with_nulls(self):
+ constraint = CheckConstraint(
+ check=Q(ints__isnull=True) | Q(ints__startswith__gte=0),
+ name="ints_optional_positive_range",
+ )
+ constraint.validate(RangesModel, RangesModel())
+ constraint = CheckConstraint(
+ check=Q(ints__startswith__gte=0),
+ name="ints_positive_range",
+ )
+ constraint.validate(RangesModel, RangesModel())
+
+ def test_opclass(self):
+ constraint = UniqueConstraint(
+ name="test_opclass",
+ fields=["scene"],
+ opclasses=["varchar_pattern_ops"],
+ )
+ with connection.schema_editor() as editor:
+ editor.add_constraint(Scene, constraint)
+ self.assertIn(constraint.name, self.get_constraints(Scene._meta.db_table))
+ with editor.connection.cursor() as cursor:
+ cursor.execute(self.get_opclass_query, [constraint.name])
+ self.assertEqual(
+ cursor.fetchall(),
+ [("varchar_pattern_ops", constraint.name)],
+ )
+ # Drop the constraint.
+ with connection.schema_editor() as editor:
+ editor.remove_constraint(Scene, constraint)
+ self.assertNotIn(constraint.name, self.get_constraints(Scene._meta.db_table))
+
+ def test_opclass_multiple_columns(self):
+ constraint = UniqueConstraint(
+ name="test_opclass_multiple",
+ fields=["scene", "setting"],
+ opclasses=["varchar_pattern_ops", "text_pattern_ops"],
+ )
+ with connection.schema_editor() as editor:
+ editor.add_constraint(Scene, constraint)
+ with editor.connection.cursor() as cursor:
+ cursor.execute(self.get_opclass_query, [constraint.name])
+ expected_opclasses = (
+ ("varchar_pattern_ops", constraint.name),
+ ("text_pattern_ops", constraint.name),
+ )
+ self.assertCountEqual(cursor.fetchall(), expected_opclasses)
+
+ def test_opclass_partial(self):
+ constraint = UniqueConstraint(
+ name="test_opclass_partial",
+ fields=["scene"],
+ opclasses=["varchar_pattern_ops"],
+ condition=Q(setting__contains="Sir Bedemir's Castle"),
+ )
+ with connection.schema_editor() as editor:
+ editor.add_constraint(Scene, constraint)
+ with editor.connection.cursor() as cursor:
+ cursor.execute(self.get_opclass_query, [constraint.name])
+ self.assertCountEqual(
+ cursor.fetchall(),
+ [("varchar_pattern_ops", constraint.name)],
+ )
+
+ @skipUnlessDBFeature("supports_covering_indexes")
+ def test_opclass_include(self):
+ constraint = UniqueConstraint(
+ name="test_opclass_include",
+ fields=["scene"],
+ opclasses=["varchar_pattern_ops"],
+ include=["setting"],
+ )
+ with connection.schema_editor() as editor:
+ editor.add_constraint(Scene, constraint)
+ with editor.connection.cursor() as cursor:
+ cursor.execute(self.get_opclass_query, [constraint.name])
+ self.assertCountEqual(
+ cursor.fetchall(),
+ [("varchar_pattern_ops", constraint.name)],
+ )
+
+ @skipUnlessDBFeature("supports_expression_indexes")
+ def test_opclass_func(self):
+ constraint = UniqueConstraint(
+ OpClass(Lower("scene"), name="text_pattern_ops"),
+ name="test_opclass_func",
+ )
+ with connection.schema_editor() as editor:
+ editor.add_constraint(Scene, constraint)
+ constraints = self.get_constraints(Scene._meta.db_table)
+ self.assertIs(constraints[constraint.name]["unique"], True)
+ self.assertIn(constraint.name, constraints)
+ with editor.connection.cursor() as cursor:
+ cursor.execute(self.get_opclass_query, [constraint.name])
+ self.assertEqual(
+ cursor.fetchall(),
+ [("text_pattern_ops", constraint.name)],
+ )
+ Scene.objects.create(scene="Scene 10", setting="The dark forest of Ewing")
+ with self.assertRaises(IntegrityError), transaction.atomic():
+ Scene.objects.create(scene="ScEnE 10", setting="Sir Bedemir's Castle")
+ Scene.objects.create(scene="Scene 5", setting="Sir Bedemir's Castle")
+ # Drop the constraint.
+ with connection.schema_editor() as editor:
+ editor.remove_constraint(Scene, constraint)
+ self.assertNotIn(constraint.name, self.get_constraints(Scene._meta.db_table))
+ Scene.objects.create(scene="ScEnE 10", setting="Sir Bedemir's Castle")
+
+
+class ExclusionConstraintTests(PostgreSQLTestCase):
+ def get_constraints(self, table):
+ """Get the constraints on the table using a new cursor."""
+ with connection.cursor() as cursor:
+ return connection.introspection.get_constraints(cursor, table)
+
+ def test_invalid_condition(self):
+ msg = "ExclusionConstraint.condition must be a Q instance."
+ with self.assertRaisesMessage(ValueError, msg):
+ ExclusionConstraint(
+ index_type="GIST",
+ name="exclude_invalid_condition",
+ expressions=[(F("datespan"), RangeOperators.OVERLAPS)],
+ condition=F("invalid"),
+ )
+
+ def test_invalid_index_type(self):
+ msg = "Exclusion constraints only support GiST or SP-GiST indexes."
+ with self.assertRaisesMessage(ValueError, msg):
+ ExclusionConstraint(
+ index_type="gin",
+ name="exclude_invalid_index_type",
+ expressions=[(F("datespan"), RangeOperators.OVERLAPS)],
+ )
+
+ def test_invalid_expressions(self):
+ msg = "The expressions must be a list of 2-tuples."
+ for expressions in (["foo"], [("foo")], [("foo_1", "foo_2", "foo_3")]):
+ with self.subTest(expressions), self.assertRaisesMessage(ValueError, msg):
+ ExclusionConstraint(
+ index_type="GIST",
+ name="exclude_invalid_expressions",
+ expressions=expressions,
+ )
+
+ def test_empty_expressions(self):
+ msg = "At least one expression is required to define an exclusion constraint."
+ for empty_expressions in (None, []):
+ with self.subTest(empty_expressions), self.assertRaisesMessage(
+ ValueError, msg
+ ):
+ ExclusionConstraint(
+ index_type="GIST",
+ name="exclude_empty_expressions",
+ expressions=empty_expressions,
+ )
+
+ def test_invalid_deferrable(self):
+ msg = "ExclusionConstraint.deferrable must be a Deferrable instance."
+ with self.assertRaisesMessage(ValueError, msg):
+ ExclusionConstraint(
+ name="exclude_invalid_deferrable",
+ expressions=[(F("datespan"), RangeOperators.OVERLAPS)],
+ deferrable="invalid",
+ )
+
+ def test_invalid_include_type(self):
+ msg = "ExclusionConstraint.include must be a list or tuple."
+ with self.assertRaisesMessage(ValueError, msg):
+ ExclusionConstraint(
+ name="exclude_invalid_include",
+ expressions=[(F("datespan"), RangeOperators.OVERLAPS)],
+ include="invalid",
+ )
+
+ def test_repr(self):
+ constraint = ExclusionConstraint(
+ name="exclude_overlapping",
+ expressions=[
+ (F("datespan"), RangeOperators.OVERLAPS),
+ (F("room"), RangeOperators.EQUAL),
+ ],
+ )
+ self.assertEqual(
+ repr(constraint),
+ "",
+ )
+ constraint = ExclusionConstraint(
+ name="exclude_overlapping",
+ expressions=[(F("datespan"), RangeOperators.ADJACENT_TO)],
+ condition=Q(cancelled=False),
+ index_type="SPGiST",
+ )
+ self.assertEqual(
+ repr(constraint),
+ "",
+ )
+ constraint = ExclusionConstraint(
+ name="exclude_overlapping",
+ expressions=[(F("datespan"), RangeOperators.ADJACENT_TO)],
+ deferrable=Deferrable.IMMEDIATE,
+ )
+ self.assertEqual(
+ repr(constraint),
+ "",
+ )
+ constraint = ExclusionConstraint(
+ name="exclude_overlapping",
+ expressions=[(F("datespan"), RangeOperators.ADJACENT_TO)],
+ include=["cancelled", "room"],
+ )
+ self.assertEqual(
+ repr(constraint),
+ "",
+ )
+ constraint = ExclusionConstraint(
+ name="exclude_overlapping",
+ expressions=[
+ (OpClass("datespan", name="range_ops"), RangeOperators.ADJACENT_TO),
+ ],
+ )
+ self.assertEqual(
+ repr(constraint),
+ "",
+ )
+ constraint = ExclusionConstraint(
+ name="exclude_overlapping",
+ expressions=[(F("datespan"), RangeOperators.ADJACENT_TO)],
+ violation_error_message="Overlapping must be excluded",
+ )
+ self.assertEqual(
+ repr(constraint),
+ "",
+ )
+ constraint = ExclusionConstraint(
+ name="exclude_overlapping",
+ expressions=[(F("datespan"), RangeOperators.ADJACENT_TO)],
+ violation_error_code="overlapping_must_be_excluded",
+ )
+ self.assertEqual(
+ repr(constraint),
+ "",
+ )
+
+ def test_eq(self):
+ constraint_1 = ExclusionConstraint(
+ name="exclude_overlapping",
+ expressions=[
+ (F("datespan"), RangeOperators.OVERLAPS),
+ (F("room"), RangeOperators.EQUAL),
+ ],
+ condition=Q(cancelled=False),
+ )
+ constraint_2 = ExclusionConstraint(
+ name="exclude_overlapping",
+ expressions=[
+ ("datespan", RangeOperators.OVERLAPS),
+ ("room", RangeOperators.EQUAL),
+ ],
+ )
+ constraint_3 = ExclusionConstraint(
+ name="exclude_overlapping",
+ expressions=[("datespan", RangeOperators.OVERLAPS)],
+ condition=Q(cancelled=False),
+ )
+ constraint_4 = ExclusionConstraint(
+ name="exclude_overlapping",
+ expressions=[
+ ("datespan", RangeOperators.OVERLAPS),
+ ("room", RangeOperators.EQUAL),
+ ],
+ deferrable=Deferrable.DEFERRED,
+ )
+ constraint_5 = ExclusionConstraint(
+ name="exclude_overlapping",
+ expressions=[
+ ("datespan", RangeOperators.OVERLAPS),
+ ("room", RangeOperators.EQUAL),
+ ],
+ deferrable=Deferrable.IMMEDIATE,
+ )
+ constraint_6 = ExclusionConstraint(
+ name="exclude_overlapping",
+ expressions=[
+ ("datespan", RangeOperators.OVERLAPS),
+ ("room", RangeOperators.EQUAL),
+ ],
+ deferrable=Deferrable.IMMEDIATE,
+ include=["cancelled"],
+ )
+ constraint_7 = ExclusionConstraint(
+ name="exclude_overlapping",
+ expressions=[
+ ("datespan", RangeOperators.OVERLAPS),
+ ("room", RangeOperators.EQUAL),
+ ],
+ include=["cancelled"],
+ )
+ constraint_10 = ExclusionConstraint(
+ name="exclude_overlapping",
+ expressions=[
+ (F("datespan"), RangeOperators.OVERLAPS),
+ (F("room"), RangeOperators.EQUAL),
+ ],
+ condition=Q(cancelled=False),
+ violation_error_message="custom error",
+ )
+ constraint_11 = ExclusionConstraint(
+ name="exclude_overlapping",
+ expressions=[
+ (F("datespan"), RangeOperators.OVERLAPS),
+ (F("room"), RangeOperators.EQUAL),
+ ],
+ condition=Q(cancelled=False),
+ violation_error_message="other custom error",
+ )
+ constraint_12 = ExclusionConstraint(
+ name="exclude_overlapping",
+ expressions=[
+ (F("datespan"), RangeOperators.OVERLAPS),
+ (F("room"), RangeOperators.EQUAL),
+ ],
+ condition=Q(cancelled=False),
+ violation_error_code="custom_code",
+ violation_error_message="other custom error",
+ )
+ self.assertEqual(constraint_1, constraint_1)
+ self.assertEqual(constraint_1, mock.ANY)
+ self.assertNotEqual(constraint_1, constraint_2)
+ self.assertNotEqual(constraint_1, constraint_3)
+ self.assertNotEqual(constraint_1, constraint_4)
+ self.assertNotEqual(constraint_1, constraint_10)
+ self.assertNotEqual(constraint_2, constraint_3)
+ self.assertNotEqual(constraint_2, constraint_4)
+ self.assertNotEqual(constraint_2, constraint_7)
+ self.assertNotEqual(constraint_4, constraint_5)
+ self.assertNotEqual(constraint_5, constraint_6)
+ self.assertNotEqual(constraint_1, object())
+ self.assertNotEqual(constraint_10, constraint_11)
+ self.assertNotEqual(constraint_11, constraint_12)
+ self.assertEqual(constraint_10, constraint_10)
+ self.assertEqual(constraint_12, constraint_12)
+
+ def test_deconstruct(self):
+ constraint = ExclusionConstraint(
+ name="exclude_overlapping",
+ expressions=[
+ ("datespan", RangeOperators.OVERLAPS),
+ ("room", RangeOperators.EQUAL),
+ ],
+ )
+ path, args, kwargs = constraint.deconstruct()
+ self.assertEqual(
+ path, "django.contrib.postgres.constraints.ExclusionConstraint"
+ )
+ self.assertEqual(args, ())
+ self.assertEqual(
+ kwargs,
+ {
+ "name": "exclude_overlapping",
+ "expressions": [
+ ("datespan", RangeOperators.OVERLAPS),
+ ("room", RangeOperators.EQUAL),
+ ],
+ },
+ )
+
+ def test_deconstruct_index_type(self):
+ constraint = ExclusionConstraint(
+ name="exclude_overlapping",
+ index_type="SPGIST",
+ expressions=[
+ ("datespan", RangeOperators.OVERLAPS),
+ ("room", RangeOperators.EQUAL),
+ ],
+ )
+ path, args, kwargs = constraint.deconstruct()
+ self.assertEqual(
+ path, "django.contrib.postgres.constraints.ExclusionConstraint"
+ )
+ self.assertEqual(args, ())
+ self.assertEqual(
+ kwargs,
+ {
+ "name": "exclude_overlapping",
+ "index_type": "SPGIST",
+ "expressions": [
+ ("datespan", RangeOperators.OVERLAPS),
+ ("room", RangeOperators.EQUAL),
+ ],
+ },
+ )
+
+ def test_deconstruct_condition(self):
+ constraint = ExclusionConstraint(
+ name="exclude_overlapping",
+ expressions=[
+ ("datespan", RangeOperators.OVERLAPS),
+ ("room", RangeOperators.EQUAL),
+ ],
+ condition=Q(cancelled=False),
+ )
+ path, args, kwargs = constraint.deconstruct()
+ self.assertEqual(
+ path, "django.contrib.postgres.constraints.ExclusionConstraint"
+ )
+ self.assertEqual(args, ())
+ self.assertEqual(
+ kwargs,
+ {
+ "name": "exclude_overlapping",
+ "expressions": [
+ ("datespan", RangeOperators.OVERLAPS),
+ ("room", RangeOperators.EQUAL),
+ ],
+ "condition": Q(cancelled=False),
+ },
+ )
+
+ def test_deconstruct_deferrable(self):
+ constraint = ExclusionConstraint(
+ name="exclude_overlapping",
+ expressions=[("datespan", RangeOperators.OVERLAPS)],
+ deferrable=Deferrable.DEFERRED,
+ )
+ path, args, kwargs = constraint.deconstruct()
+ self.assertEqual(
+ path, "django.contrib.postgres.constraints.ExclusionConstraint"
+ )
+ self.assertEqual(args, ())
+ self.assertEqual(
+ kwargs,
+ {
+ "name": "exclude_overlapping",
+ "expressions": [("datespan", RangeOperators.OVERLAPS)],
+ "deferrable": Deferrable.DEFERRED,
+ },
+ )
+
+ def test_deconstruct_include(self):
+ constraint = ExclusionConstraint(
+ name="exclude_overlapping",
+ expressions=[("datespan", RangeOperators.OVERLAPS)],
+ include=["cancelled", "room"],
+ )
+ path, args, kwargs = constraint.deconstruct()
+ self.assertEqual(
+ path, "django.contrib.postgres.constraints.ExclusionConstraint"
+ )
+ self.assertEqual(args, ())
+ self.assertEqual(
+ kwargs,
+ {
+ "name": "exclude_overlapping",
+ "expressions": [("datespan", RangeOperators.OVERLAPS)],
+ "include": ("cancelled", "room"),
+ },
+ )
+
+ def _test_range_overlaps(self, constraint):
+ # Create exclusion constraint.
+ self.assertNotIn(
+ constraint.name, self.get_constraints(HotelReservation._meta.db_table)
+ )
+ with connection.schema_editor() as editor:
+ editor.add_constraint(HotelReservation, constraint)
+ self.assertIn(
+ constraint.name, self.get_constraints(HotelReservation._meta.db_table)
+ )
+ # Add initial reservations.
+ room101 = Room.objects.create(number=101)
+ room102 = Room.objects.create(number=102)
+ datetimes = [
+ timezone.datetime(2018, 6, 20),
+ timezone.datetime(2018, 6, 24),
+ timezone.datetime(2018, 6, 26),
+ timezone.datetime(2018, 6, 28),
+ timezone.datetime(2018, 6, 29),
+ ]
+ reservation = HotelReservation.objects.create(
+ datespan=DateRange(datetimes[0].date(), datetimes[1].date()),
+ start=datetimes[0],
+ end=datetimes[1],
+ room=room102,
+ )
+ constraint.validate(HotelReservation, reservation)
+ HotelReservation.objects.create(
+ datespan=DateRange(datetimes[1].date(), datetimes[3].date()),
+ start=datetimes[1],
+ end=datetimes[3],
+ room=room102,
+ )
+ HotelReservation.objects.create(
+ datespan=DateRange(datetimes[3].date(), datetimes[4].date()),
+ start=datetimes[3],
+ end=datetimes[4],
+ room=room102,
+ cancelled=True,
+ )
+ # Overlap dates.
+ with self.assertRaises(IntegrityError), transaction.atomic():
+ reservation = HotelReservation(
+ datespan=(datetimes[1].date(), datetimes[2].date()),
+ start=datetimes[1],
+ end=datetimes[2],
+ room=room102,
+ )
+ msg = f"Constraint “{constraint.name}” is violated."
+ with self.assertRaisesMessage(ValidationError, msg):
+ constraint.validate(HotelReservation, reservation)
+ reservation.save()
+ # Valid range.
+ other_valid_reservations = [
+ # Other room.
+ HotelReservation(
+ datespan=(datetimes[1].date(), datetimes[2].date()),
+ start=datetimes[1],
+ end=datetimes[2],
+ room=room101,
+ ),
+ # Cancelled reservation.
+ HotelReservation(
+ datespan=(datetimes[1].date(), datetimes[1].date()),
+ start=datetimes[1],
+ end=datetimes[2],
+ room=room102,
+ cancelled=True,
+ ),
+ # Other adjacent dates.
+ HotelReservation(
+ datespan=(datetimes[3].date(), datetimes[4].date()),
+ start=datetimes[3],
+ end=datetimes[4],
+ room=room102,
+ ),
+ ]
+ for reservation in other_valid_reservations:
+ constraint.validate(HotelReservation, reservation)
+ HotelReservation.objects.bulk_create(other_valid_reservations)
+ # Excluded fields.
+ constraint.validate(
+ HotelReservation,
+ HotelReservation(
+ datespan=(datetimes[1].date(), datetimes[2].date()),
+ start=datetimes[1],
+ end=datetimes[2],
+ room=room102,
+ ),
+ exclude={"room"},
+ )
+ constraint.validate(
+ HotelReservation,
+ HotelReservation(
+ datespan=(datetimes[1].date(), datetimes[2].date()),
+ start=datetimes[1],
+ end=datetimes[2],
+ room=room102,
+ ),
+ exclude={"datespan", "start", "end", "room"},
+ )
+
+ def test_range_overlaps_custom(self):
+ class TsTzRange(Func):
+ function = "TSTZRANGE"
+ output_field = DateTimeRangeField()
+
+ constraint = ExclusionConstraint(
+ name="exclude_overlapping_reservations_custom_opclass",
+ expressions=[
+ (
+ OpClass(TsTzRange("start", "end", RangeBoundary()), "range_ops"),
+ RangeOperators.OVERLAPS,
+ ),
+ (OpClass("room", "gist_int4_ops"), RangeOperators.EQUAL),
+ ],
+ condition=Q(cancelled=False),
+ )
+ self._test_range_overlaps(constraint)
+
+ def test_range_overlaps(self):
+ constraint = ExclusionConstraint(
+ name="exclude_overlapping_reservations",
+ expressions=[
+ (F("datespan"), RangeOperators.OVERLAPS),
+ ("room", RangeOperators.EQUAL),
+ ],
+ condition=Q(cancelled=False),
+ )
+ self._test_range_overlaps(constraint)
+
+ def test_range_adjacent(self):
+ constraint_name = "ints_adjacent"
+ self.assertNotIn(
+ constraint_name, self.get_constraints(RangesModel._meta.db_table)
+ )
+ constraint = ExclusionConstraint(
+ name=constraint_name,
+ expressions=[("ints", RangeOperators.ADJACENT_TO)],
+ )
+ with connection.schema_editor() as editor:
+ editor.add_constraint(RangesModel, constraint)
+ self.assertIn(constraint_name, self.get_constraints(RangesModel._meta.db_table))
+ RangesModel.objects.create(ints=(20, 50))
+ with self.assertRaises(IntegrityError), transaction.atomic():
+ RangesModel.objects.create(ints=(10, 20))
+ RangesModel.objects.create(ints=(10, 19))
+ RangesModel.objects.create(ints=(51, 60))
+ # Drop the constraint.
+ with connection.schema_editor() as editor:
+ editor.remove_constraint(RangesModel, constraint)
+ self.assertNotIn(
+ constraint_name, self.get_constraints(RangesModel._meta.db_table)
+ )
+
+ def test_validate_range_adjacent(self):
+ constraint = ExclusionConstraint(
+ name="ints_adjacent",
+ expressions=[("ints", RangeOperators.ADJACENT_TO)],
+ violation_error_code="custom_code",
+ violation_error_message="Custom error message.",
+ )
+ range_obj = RangesModel.objects.create(ints=(20, 50))
+ constraint.validate(RangesModel, range_obj)
+ msg = "Custom error message."
+ with self.assertRaisesMessage(ValidationError, msg) as cm:
+ constraint.validate(RangesModel, RangesModel(ints=(10, 20)))
+ self.assertEqual(cm.exception.code, "custom_code")
+ constraint.validate(RangesModel, RangesModel(ints=(10, 19)))
+ constraint.validate(RangesModel, RangesModel(ints=(51, 60)))
+ constraint.validate(RangesModel, RangesModel(ints=(10, 20)), exclude={"ints"})
+
+ def test_validate_with_custom_code_and_condition(self):
+ constraint = ExclusionConstraint(
+ name="ints_adjacent",
+ expressions=[("ints", RangeOperators.ADJACENT_TO)],
+ violation_error_code="custom_code",
+ condition=Q(ints__lt=(100, 200)),
+ )
+ range_obj = RangesModel.objects.create(ints=(20, 50))
+ constraint.validate(RangesModel, range_obj)
+ with self.assertRaises(ValidationError) as cm:
+ constraint.validate(RangesModel, RangesModel(ints=(10, 20)))
+ self.assertEqual(cm.exception.code, "custom_code")
+
+ def test_expressions_with_params(self):
+ constraint_name = "scene_left_equal"
+ self.assertNotIn(constraint_name, self.get_constraints(Scene._meta.db_table))
+ constraint = ExclusionConstraint(
+ name=constraint_name,
+ expressions=[(Left("scene", 4), RangeOperators.EQUAL)],
+ )
+ with connection.schema_editor() as editor:
+ editor.add_constraint(Scene, constraint)
+ self.assertIn(constraint_name, self.get_constraints(Scene._meta.db_table))
+
+ def test_expressions_with_key_transform(self):
+ constraint_name = "exclude_overlapping_reservations_smoking"
+ constraint = ExclusionConstraint(
+ name=constraint_name,
+ expressions=[
+ (F("datespan"), RangeOperators.OVERLAPS),
+ (KeyTextTransform("smoking", "requirements"), RangeOperators.EQUAL),
+ ],
+ )
+ with connection.schema_editor() as editor:
+ editor.add_constraint(HotelReservation, constraint)
+ self.assertIn(
+ constraint_name,
+ self.get_constraints(HotelReservation._meta.db_table),
+ )
+
+ def test_index_transform(self):
+ constraint_name = "first_index_equal"
+ constraint = ExclusionConstraint(
+ name=constraint_name,
+ expressions=[("field__0", RangeOperators.EQUAL)],
+ )
+ with connection.schema_editor() as editor:
+ editor.add_constraint(IntegerArrayModel, constraint)
+ self.assertIn(
+ constraint_name,
+ self.get_constraints(IntegerArrayModel._meta.db_table),
+ )
+
+ def test_range_adjacent_initially_deferred(self):
+ constraint_name = "ints_adjacent_deferred"
+ self.assertNotIn(
+ constraint_name, self.get_constraints(RangesModel._meta.db_table)
+ )
+ constraint = ExclusionConstraint(
+ name=constraint_name,
+ expressions=[("ints", RangeOperators.ADJACENT_TO)],
+ deferrable=Deferrable.DEFERRED,
+ )
+ with connection.schema_editor() as editor:
+ editor.add_constraint(RangesModel, constraint)
+ self.assertIn(constraint_name, self.get_constraints(RangesModel._meta.db_table))
+ RangesModel.objects.create(ints=(20, 50))
+ adjacent_range = RangesModel.objects.create(ints=(10, 20))
+ # Constraint behavior can be changed with SET CONSTRAINTS.
+ with self.assertRaises(IntegrityError):
+ with transaction.atomic(), connection.cursor() as cursor:
+ quoted_name = connection.ops.quote_name(constraint_name)
+ cursor.execute("SET CONSTRAINTS %s IMMEDIATE" % quoted_name)
+ # Remove adjacent range before the end of transaction.
+ adjacent_range.delete()
+ RangesModel.objects.create(ints=(10, 19))
+ RangesModel.objects.create(ints=(51, 60))
+
+ def test_range_adjacent_initially_deferred_with_condition(self):
+ constraint_name = "ints_adjacent_deferred_with_condition"
+ self.assertNotIn(
+ constraint_name, self.get_constraints(RangesModel._meta.db_table)
+ )
+ constraint = ExclusionConstraint(
+ name=constraint_name,
+ expressions=[("ints", RangeOperators.ADJACENT_TO)],
+ condition=Q(ints__lt=(100, 200)),
+ deferrable=Deferrable.DEFERRED,
+ )
+ with connection.schema_editor() as editor:
+ editor.add_constraint(RangesModel, constraint)
+ self.assertIn(constraint_name, self.get_constraints(RangesModel._meta.db_table))
+ RangesModel.objects.create(ints=(20, 50))
+ adjacent_range = RangesModel.objects.create(ints=(10, 20))
+ # Constraint behavior can be changed with SET CONSTRAINTS.
+ with self.assertRaises(IntegrityError):
+ with transaction.atomic(), connection.cursor() as cursor:
+ quoted_name = connection.ops.quote_name(constraint_name)
+ cursor.execute(f"SET CONSTRAINTS {quoted_name} IMMEDIATE")
+ # Remove adjacent range before the end of transaction.
+ adjacent_range.delete()
+ RangesModel.objects.create(ints=(10, 19))
+ RangesModel.objects.create(ints=(51, 60))
+ # Add adjacent range that doesn't match the condition.
+ RangesModel.objects.create(ints=(200, 500))
+ adjacent_range = RangesModel.objects.create(ints=(100, 200))
+ # Constraint behavior can be changed with SET CONSTRAINTS.
+ with transaction.atomic(), connection.cursor() as cursor:
+ quoted_name = connection.ops.quote_name(constraint_name)
+ cursor.execute(f"SET CONSTRAINTS {quoted_name} IMMEDIATE")
+
+ def test_range_adjacent_gist_include(self):
+ constraint_name = "ints_adjacent_gist_include"
+ self.assertNotIn(
+ constraint_name, self.get_constraints(RangesModel._meta.db_table)
+ )
+ constraint = ExclusionConstraint(
+ name=constraint_name,
+ expressions=[("ints", RangeOperators.ADJACENT_TO)],
+ index_type="gist",
+ include=["decimals", "ints"],
+ )
+ with connection.schema_editor() as editor:
+ editor.add_constraint(RangesModel, constraint)
+ self.assertIn(constraint_name, self.get_constraints(RangesModel._meta.db_table))
+ RangesModel.objects.create(ints=(20, 50))
+ with self.assertRaises(IntegrityError), transaction.atomic():
+ RangesModel.objects.create(ints=(10, 20))
+ RangesModel.objects.create(ints=(10, 19))
+ RangesModel.objects.create(ints=(51, 60))
+
+ @skipUnlessDBFeature("supports_covering_spgist_indexes")
+ def test_range_adjacent_spgist_include(self):
+ constraint_name = "ints_adjacent_spgist_include"
+ self.assertNotIn(
+ constraint_name, self.get_constraints(RangesModel._meta.db_table)
+ )
+ constraint = ExclusionConstraint(
+ name=constraint_name,
+ expressions=[("ints", RangeOperators.ADJACENT_TO)],
+ index_type="spgist",
+ include=["decimals", "ints"],
+ )
+ with connection.schema_editor() as editor:
+ editor.add_constraint(RangesModel, constraint)
+ self.assertIn(constraint_name, self.get_constraints(RangesModel._meta.db_table))
+ RangesModel.objects.create(ints=(20, 50))
+ with self.assertRaises(IntegrityError), transaction.atomic():
+ RangesModel.objects.create(ints=(10, 20))
+ RangesModel.objects.create(ints=(10, 19))
+ RangesModel.objects.create(ints=(51, 60))
+
+ def test_range_adjacent_gist_include_condition(self):
+ constraint_name = "ints_adjacent_gist_include_condition"
+ self.assertNotIn(
+ constraint_name, self.get_constraints(RangesModel._meta.db_table)
+ )
+ constraint = ExclusionConstraint(
+ name=constraint_name,
+ expressions=[("ints", RangeOperators.ADJACENT_TO)],
+ index_type="gist",
+ include=["decimals"],
+ condition=Q(id__gte=100),
+ )
+ with connection.schema_editor() as editor:
+ editor.add_constraint(RangesModel, constraint)
+ self.assertIn(constraint_name, self.get_constraints(RangesModel._meta.db_table))
+
+ @skipUnlessDBFeature("supports_covering_spgist_indexes")
+ def test_range_adjacent_spgist_include_condition(self):
+ constraint_name = "ints_adjacent_spgist_include_condition"
+ self.assertNotIn(
+ constraint_name, self.get_constraints(RangesModel._meta.db_table)
+ )
+ constraint = ExclusionConstraint(
+ name=constraint_name,
+ expressions=[("ints", RangeOperators.ADJACENT_TO)],
+ index_type="spgist",
+ include=["decimals"],
+ condition=Q(id__gte=100),
+ )
+ with connection.schema_editor() as editor:
+ editor.add_constraint(RangesModel, constraint)
+ self.assertIn(constraint_name, self.get_constraints(RangesModel._meta.db_table))
+
+ def test_range_adjacent_gist_include_deferrable(self):
+ constraint_name = "ints_adjacent_gist_include_deferrable"
+ self.assertNotIn(
+ constraint_name, self.get_constraints(RangesModel._meta.db_table)
+ )
+ constraint = ExclusionConstraint(
+ name=constraint_name,
+ expressions=[("ints", RangeOperators.ADJACENT_TO)],
+ index_type="gist",
+ include=["decimals"],
+ deferrable=Deferrable.DEFERRED,
+ )
+ with connection.schema_editor() as editor:
+ editor.add_constraint(RangesModel, constraint)
+ self.assertIn(constraint_name, self.get_constraints(RangesModel._meta.db_table))
+
+ @skipUnlessDBFeature("supports_covering_spgist_indexes")
+ def test_range_adjacent_spgist_include_deferrable(self):
+ constraint_name = "ints_adjacent_spgist_include_deferrable"
+ self.assertNotIn(
+ constraint_name, self.get_constraints(RangesModel._meta.db_table)
+ )
+ constraint = ExclusionConstraint(
+ name=constraint_name,
+ expressions=[("ints", RangeOperators.ADJACENT_TO)],
+ index_type="spgist",
+ include=["decimals"],
+ deferrable=Deferrable.DEFERRED,
+ )
+ with connection.schema_editor() as editor:
+ editor.add_constraint(RangesModel, constraint)
+ self.assertIn(constraint_name, self.get_constraints(RangesModel._meta.db_table))
+
+ def test_spgist_include_not_supported(self):
+ constraint_name = "ints_adjacent_spgist_include_not_supported"
+ constraint = ExclusionConstraint(
+ name=constraint_name,
+ expressions=[("ints", RangeOperators.ADJACENT_TO)],
+ index_type="spgist",
+ include=["id"],
+ )
+ msg = (
+ "Covering exclusion constraints using an SP-GiST index require "
+ "PostgreSQL 14+."
+ )
+ with connection.schema_editor() as editor:
+ with mock.patch(
+ "django.db.backends.postgresql.features.DatabaseFeatures."
+ "supports_covering_spgist_indexes",
+ False,
+ ):
+ with self.assertRaisesMessage(NotSupportedError, msg):
+ editor.add_constraint(RangesModel, constraint)
+
+ def test_range_adjacent_opclass(self):
+ constraint_name = "ints_adjacent_opclass"
+ self.assertNotIn(
+ constraint_name, self.get_constraints(RangesModel._meta.db_table)
+ )
+ constraint = ExclusionConstraint(
+ name=constraint_name,
+ expressions=[
+ (OpClass("ints", name="range_ops"), RangeOperators.ADJACENT_TO),
+ ],
+ )
+ with connection.schema_editor() as editor:
+ editor.add_constraint(RangesModel, constraint)
+ constraints = self.get_constraints(RangesModel._meta.db_table)
+ self.assertIn(constraint_name, constraints)
+ with editor.connection.cursor() as cursor:
+ cursor.execute(SchemaTests.get_opclass_query, [constraint_name])
+ self.assertEqual(
+ cursor.fetchall(),
+ [("range_ops", constraint_name)],
+ )
+ RangesModel.objects.create(ints=(20, 50))
+ with self.assertRaises(IntegrityError), transaction.atomic():
+ RangesModel.objects.create(ints=(10, 20))
+ RangesModel.objects.create(ints=(10, 19))
+ RangesModel.objects.create(ints=(51, 60))
+ # Drop the constraint.
+ with connection.schema_editor() as editor:
+ editor.remove_constraint(RangesModel, constraint)
+ self.assertNotIn(
+ constraint_name, self.get_constraints(RangesModel._meta.db_table)
+ )
+
+ def test_range_adjacent_opclass_condition(self):
+ constraint_name = "ints_adjacent_opclass_condition"
+ self.assertNotIn(
+ constraint_name, self.get_constraints(RangesModel._meta.db_table)
+ )
+ constraint = ExclusionConstraint(
+ name=constraint_name,
+ expressions=[
+ (OpClass("ints", name="range_ops"), RangeOperators.ADJACENT_TO),
+ ],
+ condition=Q(id__gte=100),
+ )
+ with connection.schema_editor() as editor:
+ editor.add_constraint(RangesModel, constraint)
+ self.assertIn(constraint_name, self.get_constraints(RangesModel._meta.db_table))
+
+ def test_range_adjacent_opclass_deferrable(self):
+ constraint_name = "ints_adjacent_opclass_deferrable"
+ self.assertNotIn(
+ constraint_name, self.get_constraints(RangesModel._meta.db_table)
+ )
+ constraint = ExclusionConstraint(
+ name=constraint_name,
+ expressions=[
+ (OpClass("ints", name="range_ops"), RangeOperators.ADJACENT_TO),
+ ],
+ deferrable=Deferrable.DEFERRED,
+ )
+ with connection.schema_editor() as editor:
+ editor.add_constraint(RangesModel, constraint)
+ self.assertIn(constraint_name, self.get_constraints(RangesModel._meta.db_table))
+
+ def test_range_adjacent_gist_opclass_include(self):
+ constraint_name = "ints_adjacent_gist_opclass_include"
+ self.assertNotIn(
+ constraint_name, self.get_constraints(RangesModel._meta.db_table)
+ )
+ constraint = ExclusionConstraint(
+ name=constraint_name,
+ expressions=[
+ (OpClass("ints", name="range_ops"), RangeOperators.ADJACENT_TO),
+ ],
+ index_type="gist",
+ include=["decimals"],
+ )
+ with connection.schema_editor() as editor:
+ editor.add_constraint(RangesModel, constraint)
+ self.assertIn(constraint_name, self.get_constraints(RangesModel._meta.db_table))
+
+ @skipUnlessDBFeature("supports_covering_spgist_indexes")
+ def test_range_adjacent_spgist_opclass_include(self):
+ constraint_name = "ints_adjacent_spgist_opclass_include"
+ self.assertNotIn(
+ constraint_name, self.get_constraints(RangesModel._meta.db_table)
+ )
+ constraint = ExclusionConstraint(
+ name=constraint_name,
+ expressions=[
+ (OpClass("ints", name="range_ops"), RangeOperators.ADJACENT_TO),
+ ],
+ index_type="spgist",
+ include=["decimals"],
+ )
+ with connection.schema_editor() as editor:
+ editor.add_constraint(RangesModel, constraint)
+ self.assertIn(constraint_name, self.get_constraints(RangesModel._meta.db_table))
+
+ def test_range_equal_cast(self):
+ constraint_name = "exclusion_equal_room_cast"
+ self.assertNotIn(constraint_name, self.get_constraints(Room._meta.db_table))
+ constraint = ExclusionConstraint(
+ name=constraint_name,
+ expressions=[(Cast("number", IntegerField()), RangeOperators.EQUAL)],
+ )
+ with connection.schema_editor() as editor:
+ editor.add_constraint(Room, constraint)
+ self.assertIn(constraint_name, self.get_constraints(Room._meta.db_table))
+
+ @isolate_apps("postgres_tests")
+ def test_table_create(self):
+ constraint_name = "exclusion_equal_number_tc"
+
+ class ModelWithExclusionConstraint(Model):
+ number = IntegerField()
+
+ class Meta:
+ app_label = "postgres_tests"
+ constraints = [
+ ExclusionConstraint(
+ name=constraint_name,
+ expressions=[("number", RangeOperators.EQUAL)],
+ )
+ ]
+
+ with connection.schema_editor() as editor:
+ editor.create_model(ModelWithExclusionConstraint)
+ self.assertIn(
+ constraint_name,
+ self.get_constraints(ModelWithExclusionConstraint._meta.db_table),
+ )
diff --git a/testbed/django__django/tests/postgres_tests/test_functions.py b/testbed/django__django/tests/postgres_tests/test_functions.py
new file mode 100644
index 0000000000000000000000000000000000000000..e5005806452e63906c22172d10b6719d7282b672
--- /dev/null
+++ b/testbed/django__django/tests/postgres_tests/test_functions.py
@@ -0,0 +1,39 @@
+import uuid
+from datetime import datetime
+from time import sleep
+
+from django.contrib.postgres.functions import RandomUUID, TransactionNow
+
+from . import PostgreSQLTestCase
+from .models import NowTestModel, UUIDTestModel
+
+
+class TestTransactionNow(PostgreSQLTestCase):
+ def test_transaction_now(self):
+ """
+ The test case puts everything under a transaction, so two models
+ updated with a short gap should have the same time.
+ """
+ m1 = NowTestModel.objects.create()
+ m2 = NowTestModel.objects.create()
+
+ NowTestModel.objects.filter(id=m1.id).update(when=TransactionNow())
+ sleep(0.1)
+ NowTestModel.objects.filter(id=m2.id).update(when=TransactionNow())
+
+ m1.refresh_from_db()
+ m2.refresh_from_db()
+
+ self.assertIsInstance(m1.when, datetime)
+ self.assertEqual(m1.when, m2.when)
+
+
+class TestRandomUUID(PostgreSQLTestCase):
+ def test_random_uuid(self):
+ m1 = UUIDTestModel.objects.create()
+ m2 = UUIDTestModel.objects.create()
+ UUIDTestModel.objects.update(uuid=RandomUUID())
+ m1.refresh_from_db()
+ m2.refresh_from_db()
+ self.assertIsInstance(m1.uuid, uuid.UUID)
+ self.assertNotEqual(m1.uuid, m2.uuid)
diff --git a/testbed/django__django/tests/postgres_tests/test_hstore.py b/testbed/django__django/tests/postgres_tests/test_hstore.py
new file mode 100644
index 0000000000000000000000000000000000000000..2aaad637c65527481e0ba733d7de47da718688b3
--- /dev/null
+++ b/testbed/django__django/tests/postgres_tests/test_hstore.py
@@ -0,0 +1,461 @@
+import json
+
+from django.core import checks, exceptions, serializers
+from django.db import connection
+from django.db.models import F, OuterRef, Subquery
+from django.db.models.expressions import RawSQL
+from django.forms import Form
+from django.test.utils import CaptureQueriesContext, isolate_apps
+
+from . import PostgreSQLSimpleTestCase, PostgreSQLTestCase
+from .models import HStoreModel, PostgreSQLModel
+
+try:
+ from django.contrib.postgres import forms
+ from django.contrib.postgres.fields import HStoreField
+ from django.contrib.postgres.fields.hstore import KeyTransform
+ from django.contrib.postgres.validators import KeysValidator
+except ImportError:
+ pass
+
+
+class SimpleTests(PostgreSQLTestCase):
+ def test_save_load_success(self):
+ value = {"a": "b"}
+ instance = HStoreModel(field=value)
+ instance.save()
+ reloaded = HStoreModel.objects.get()
+ self.assertEqual(reloaded.field, value)
+
+ def test_null(self):
+ instance = HStoreModel(field=None)
+ instance.save()
+ reloaded = HStoreModel.objects.get()
+ self.assertIsNone(reloaded.field)
+
+ def test_value_null(self):
+ value = {"a": None}
+ instance = HStoreModel(field=value)
+ instance.save()
+ reloaded = HStoreModel.objects.get()
+ self.assertEqual(reloaded.field, value)
+
+ def test_key_val_cast_to_string(self):
+ value = {"a": 1, "b": "B", 2: "c", "ï": "ê"}
+ expected_value = {"a": "1", "b": "B", "2": "c", "ï": "ê"}
+
+ instance = HStoreModel.objects.create(field=value)
+ instance = HStoreModel.objects.get()
+ self.assertEqual(instance.field, expected_value)
+
+ instance = HStoreModel.objects.get(field__a=1)
+ self.assertEqual(instance.field, expected_value)
+
+ instance = HStoreModel.objects.get(field__has_keys=[2, "a", "ï"])
+ self.assertEqual(instance.field, expected_value)
+
+ def test_array_field(self):
+ value = [
+ {"a": 1, "b": "B", 2: "c", "ï": "ê"},
+ {"a": 1, "b": "B", 2: "c", "ï": "ê"},
+ ]
+ expected_value = [
+ {"a": "1", "b": "B", "2": "c", "ï": "ê"},
+ {"a": "1", "b": "B", "2": "c", "ï": "ê"},
+ ]
+ instance = HStoreModel.objects.create(array_field=value)
+ instance.refresh_from_db()
+ self.assertEqual(instance.array_field, expected_value)
+
+
+class TestQuerying(PostgreSQLTestCase):
+ @classmethod
+ def setUpTestData(cls):
+ cls.objs = HStoreModel.objects.bulk_create(
+ [
+ HStoreModel(field={"a": "b"}),
+ HStoreModel(field={"a": "b", "c": "d"}),
+ HStoreModel(field={"c": "d"}),
+ HStoreModel(field={}),
+ HStoreModel(field=None),
+ HStoreModel(field={"cat": "TigrOu", "breed": "birman"}),
+ HStoreModel(field={"cat": "minou", "breed": "ragdoll"}),
+ HStoreModel(field={"cat": "kitty", "breed": "Persian"}),
+ HStoreModel(field={"cat": "Kit Kat", "breed": "persian"}),
+ ]
+ )
+
+ def test_exact(self):
+ self.assertSequenceEqual(
+ HStoreModel.objects.filter(field__exact={"a": "b"}), self.objs[:1]
+ )
+
+ def test_contained_by(self):
+ self.assertSequenceEqual(
+ HStoreModel.objects.filter(field__contained_by={"a": "b", "c": "d"}),
+ self.objs[:4],
+ )
+
+ def test_contains(self):
+ self.assertSequenceEqual(
+ HStoreModel.objects.filter(field__contains={"a": "b"}), self.objs[:2]
+ )
+
+ def test_in_generator(self):
+ def search():
+ yield {"a": "b"}
+
+ self.assertSequenceEqual(
+ HStoreModel.objects.filter(field__in=search()), self.objs[:1]
+ )
+
+ def test_has_key(self):
+ self.assertSequenceEqual(
+ HStoreModel.objects.filter(field__has_key="c"), self.objs[1:3]
+ )
+
+ def test_has_keys(self):
+ self.assertSequenceEqual(
+ HStoreModel.objects.filter(field__has_keys=["a", "c"]), self.objs[1:2]
+ )
+
+ def test_has_any_keys(self):
+ self.assertSequenceEqual(
+ HStoreModel.objects.filter(field__has_any_keys=["a", "c"]), self.objs[:3]
+ )
+
+ def test_key_transform(self):
+ self.assertSequenceEqual(
+ HStoreModel.objects.filter(field__a="b"), self.objs[:2]
+ )
+
+ def test_key_transform_raw_expression(self):
+ expr = RawSQL("%s::hstore", ["x => b, y => c"])
+ self.assertSequenceEqual(
+ HStoreModel.objects.filter(field__a=KeyTransform("x", expr)), self.objs[:2]
+ )
+
+ def test_key_transform_annotation(self):
+ qs = HStoreModel.objects.annotate(a=F("field__a"))
+ self.assertCountEqual(
+ qs.values_list("a", flat=True),
+ ["b", "b", None, None, None, None, None, None, None],
+ )
+
+ def test_keys(self):
+ self.assertSequenceEqual(
+ HStoreModel.objects.filter(field__keys=["a"]), self.objs[:1]
+ )
+
+ def test_values(self):
+ self.assertSequenceEqual(
+ HStoreModel.objects.filter(field__values=["b"]), self.objs[:1]
+ )
+
+ def test_field_chaining_contains(self):
+ self.assertSequenceEqual(
+ HStoreModel.objects.filter(field__a__contains="b"), self.objs[:2]
+ )
+
+ def test_field_chaining_icontains(self):
+ self.assertSequenceEqual(
+ HStoreModel.objects.filter(field__cat__icontains="INo"),
+ [self.objs[6]],
+ )
+
+ def test_field_chaining_startswith(self):
+ self.assertSequenceEqual(
+ HStoreModel.objects.filter(field__cat__startswith="kit"),
+ [self.objs[7]],
+ )
+
+ def test_field_chaining_istartswith(self):
+ self.assertSequenceEqual(
+ HStoreModel.objects.filter(field__cat__istartswith="kit"),
+ self.objs[7:],
+ )
+
+ def test_field_chaining_endswith(self):
+ self.assertSequenceEqual(
+ HStoreModel.objects.filter(field__cat__endswith="ou"),
+ [self.objs[6]],
+ )
+
+ def test_field_chaining_iendswith(self):
+ self.assertSequenceEqual(
+ HStoreModel.objects.filter(field__cat__iendswith="ou"),
+ self.objs[5:7],
+ )
+
+ def test_field_chaining_iexact(self):
+ self.assertSequenceEqual(
+ HStoreModel.objects.filter(field__breed__iexact="persian"),
+ self.objs[7:],
+ )
+
+ def test_field_chaining_regex(self):
+ self.assertSequenceEqual(
+ HStoreModel.objects.filter(field__cat__regex=r"ou$"),
+ [self.objs[6]],
+ )
+
+ def test_field_chaining_iregex(self):
+ self.assertSequenceEqual(
+ HStoreModel.objects.filter(field__cat__iregex=r"oU$"),
+ self.objs[5:7],
+ )
+
+ def test_order_by_field(self):
+ more_objs = (
+ HStoreModel.objects.create(field={"g": "637"}),
+ HStoreModel.objects.create(field={"g": "002"}),
+ HStoreModel.objects.create(field={"g": "042"}),
+ HStoreModel.objects.create(field={"g": "981"}),
+ )
+ self.assertSequenceEqual(
+ HStoreModel.objects.filter(field__has_key="g").order_by("field__g"),
+ [more_objs[1], more_objs[2], more_objs[0], more_objs[3]],
+ )
+
+ def test_keys_contains(self):
+ self.assertSequenceEqual(
+ HStoreModel.objects.filter(field__keys__contains=["a"]), self.objs[:2]
+ )
+
+ def test_values_overlap(self):
+ self.assertSequenceEqual(
+ HStoreModel.objects.filter(field__values__overlap=["b", "d"]), self.objs[:3]
+ )
+
+ def test_key_isnull(self):
+ obj = HStoreModel.objects.create(field={"a": None})
+ self.assertSequenceEqual(
+ HStoreModel.objects.filter(field__a__isnull=True),
+ self.objs[2:9] + [obj],
+ )
+ self.assertSequenceEqual(
+ HStoreModel.objects.filter(field__a__isnull=False), self.objs[:2]
+ )
+
+ def test_usage_in_subquery(self):
+ self.assertSequenceEqual(
+ HStoreModel.objects.filter(id__in=HStoreModel.objects.filter(field__a="b")),
+ self.objs[:2],
+ )
+
+ def test_key_sql_injection(self):
+ with CaptureQueriesContext(connection) as queries:
+ self.assertFalse(
+ HStoreModel.objects.filter(
+ **{
+ "field__test' = 'a') OR 1 = 1 OR ('d": "x",
+ }
+ ).exists()
+ )
+ self.assertIn(
+ """."field" -> 'test'' = ''a'') OR 1 = 1 OR (''d') = 'x' """,
+ queries[0]["sql"],
+ )
+
+ def test_obj_subquery_lookup(self):
+ qs = HStoreModel.objects.annotate(
+ value=Subquery(
+ HStoreModel.objects.filter(pk=OuterRef("pk")).values("field")
+ ),
+ ).filter(value__a="b")
+ self.assertSequenceEqual(qs, self.objs[:2])
+
+
+@isolate_apps("postgres_tests")
+class TestChecks(PostgreSQLSimpleTestCase):
+ def test_invalid_default(self):
+ class MyModel(PostgreSQLModel):
+ field = HStoreField(default={})
+
+ model = MyModel()
+ self.assertEqual(
+ model.check(),
+ [
+ checks.Warning(
+ msg=(
+ "HStoreField default should be a callable instead of an "
+ "instance so that it's not shared between all field "
+ "instances."
+ ),
+ hint="Use a callable instead, e.g., use `dict` instead of `{}`.",
+ obj=MyModel._meta.get_field("field"),
+ id="fields.E010",
+ )
+ ],
+ )
+
+ def test_valid_default(self):
+ class MyModel(PostgreSQLModel):
+ field = HStoreField(default=dict)
+
+ self.assertEqual(MyModel().check(), [])
+
+
+class TestSerialization(PostgreSQLSimpleTestCase):
+ test_data = json.dumps(
+ [
+ {
+ "model": "postgres_tests.hstoremodel",
+ "pk": None,
+ "fields": {
+ "field": json.dumps({"a": "b"}),
+ "array_field": json.dumps(
+ [
+ json.dumps({"a": "b"}),
+ json.dumps({"b": "a"}),
+ ]
+ ),
+ },
+ }
+ ]
+ )
+
+ def test_dumping(self):
+ instance = HStoreModel(field={"a": "b"}, array_field=[{"a": "b"}, {"b": "a"}])
+ data = serializers.serialize("json", [instance])
+ self.assertEqual(json.loads(data), json.loads(self.test_data))
+
+ def test_loading(self):
+ instance = list(serializers.deserialize("json", self.test_data))[0].object
+ self.assertEqual(instance.field, {"a": "b"})
+ self.assertEqual(instance.array_field, [{"a": "b"}, {"b": "a"}])
+
+ def test_roundtrip_with_null(self):
+ instance = HStoreModel(field={"a": "b", "c": None})
+ data = serializers.serialize("json", [instance])
+ new_instance = list(serializers.deserialize("json", data))[0].object
+ self.assertEqual(instance.field, new_instance.field)
+
+
+class TestValidation(PostgreSQLSimpleTestCase):
+ def test_not_a_string(self):
+ field = HStoreField()
+ with self.assertRaises(exceptions.ValidationError) as cm:
+ field.clean({"a": 1}, None)
+ self.assertEqual(cm.exception.code, "not_a_string")
+ self.assertEqual(
+ cm.exception.message % cm.exception.params,
+ "The value of “a” is not a string or null.",
+ )
+
+ def test_none_allowed_as_value(self):
+ field = HStoreField()
+ self.assertEqual(field.clean({"a": None}, None), {"a": None})
+
+
+class TestFormField(PostgreSQLSimpleTestCase):
+ def test_valid(self):
+ field = forms.HStoreField()
+ value = field.clean('{"a": "b"}')
+ self.assertEqual(value, {"a": "b"})
+
+ def test_invalid_json(self):
+ field = forms.HStoreField()
+ with self.assertRaises(exceptions.ValidationError) as cm:
+ field.clean('{"a": "b"')
+ self.assertEqual(cm.exception.messages[0], "Could not load JSON data.")
+ self.assertEqual(cm.exception.code, "invalid_json")
+
+ def test_non_dict_json(self):
+ field = forms.HStoreField()
+ msg = "Input must be a JSON dictionary."
+ with self.assertRaisesMessage(exceptions.ValidationError, msg) as cm:
+ field.clean('["a", "b", 1]')
+ self.assertEqual(cm.exception.code, "invalid_format")
+
+ def test_not_string_values(self):
+ field = forms.HStoreField()
+ value = field.clean('{"a": 1}')
+ self.assertEqual(value, {"a": "1"})
+
+ def test_none_value(self):
+ field = forms.HStoreField()
+ value = field.clean('{"a": null}')
+ self.assertEqual(value, {"a": None})
+
+ def test_empty(self):
+ field = forms.HStoreField(required=False)
+ value = field.clean("")
+ self.assertEqual(value, {})
+
+ def test_model_field_formfield(self):
+ model_field = HStoreField()
+ form_field = model_field.formfield()
+ self.assertIsInstance(form_field, forms.HStoreField)
+
+ def test_field_has_changed(self):
+ class HStoreFormTest(Form):
+ f1 = forms.HStoreField()
+
+ form_w_hstore = HStoreFormTest()
+ self.assertFalse(form_w_hstore.has_changed())
+
+ form_w_hstore = HStoreFormTest({"f1": '{"a": 1}'})
+ self.assertTrue(form_w_hstore.has_changed())
+
+ form_w_hstore = HStoreFormTest({"f1": '{"a": 1}'}, initial={"f1": '{"a": 1}'})
+ self.assertFalse(form_w_hstore.has_changed())
+
+ form_w_hstore = HStoreFormTest({"f1": '{"a": 2}'}, initial={"f1": '{"a": 1}'})
+ self.assertTrue(form_w_hstore.has_changed())
+
+ form_w_hstore = HStoreFormTest({"f1": '{"a": 1}'}, initial={"f1": {"a": 1}})
+ self.assertFalse(form_w_hstore.has_changed())
+
+ form_w_hstore = HStoreFormTest({"f1": '{"a": 2}'}, initial={"f1": {"a": 1}})
+ self.assertTrue(form_w_hstore.has_changed())
+
+
+class TestValidator(PostgreSQLSimpleTestCase):
+ def test_simple_valid(self):
+ validator = KeysValidator(keys=["a", "b"])
+ validator({"a": "foo", "b": "bar", "c": "baz"})
+
+ def test_missing_keys(self):
+ validator = KeysValidator(keys=["a", "b"])
+ with self.assertRaises(exceptions.ValidationError) as cm:
+ validator({"a": "foo", "c": "baz"})
+ self.assertEqual(cm.exception.messages[0], "Some keys were missing: b")
+ self.assertEqual(cm.exception.code, "missing_keys")
+
+ def test_strict_valid(self):
+ validator = KeysValidator(keys=["a", "b"], strict=True)
+ validator({"a": "foo", "b": "bar"})
+
+ def test_extra_keys(self):
+ validator = KeysValidator(keys=["a", "b"], strict=True)
+ with self.assertRaises(exceptions.ValidationError) as cm:
+ validator({"a": "foo", "b": "bar", "c": "baz"})
+ self.assertEqual(cm.exception.messages[0], "Some unknown keys were provided: c")
+ self.assertEqual(cm.exception.code, "extra_keys")
+
+ def test_custom_messages(self):
+ messages = {
+ "missing_keys": "Foobar",
+ }
+ validator = KeysValidator(keys=["a", "b"], strict=True, messages=messages)
+ with self.assertRaises(exceptions.ValidationError) as cm:
+ validator({"a": "foo", "c": "baz"})
+ self.assertEqual(cm.exception.messages[0], "Foobar")
+ self.assertEqual(cm.exception.code, "missing_keys")
+ with self.assertRaises(exceptions.ValidationError) as cm:
+ validator({"a": "foo", "b": "bar", "c": "baz"})
+ self.assertEqual(cm.exception.messages[0], "Some unknown keys were provided: c")
+ self.assertEqual(cm.exception.code, "extra_keys")
+
+ def test_deconstruct(self):
+ messages = {
+ "missing_keys": "Foobar",
+ }
+ validator = KeysValidator(keys=["a", "b"], strict=True, messages=messages)
+ path, args, kwargs = validator.deconstruct()
+ self.assertEqual(path, "django.contrib.postgres.validators.KeysValidator")
+ self.assertEqual(args, ())
+ self.assertEqual(
+ kwargs, {"keys": ["a", "b"], "strict": True, "messages": messages}
+ )
diff --git a/testbed/django__django/tests/postgres_tests/test_indexes.py b/testbed/django__django/tests/postgres_tests/test_indexes.py
new file mode 100644
index 0000000000000000000000000000000000000000..d063ac64a2d1c4ad6da4d23c3aeaf75d9ea0c1c5
--- /dev/null
+++ b/testbed/django__django/tests/postgres_tests/test_indexes.py
@@ -0,0 +1,740 @@
+from unittest import mock
+
+from django.contrib.postgres.indexes import (
+ BloomIndex,
+ BrinIndex,
+ BTreeIndex,
+ GinIndex,
+ GistIndex,
+ HashIndex,
+ OpClass,
+ PostgresIndex,
+ SpGistIndex,
+)
+from django.db import NotSupportedError, connection
+from django.db.models import CharField, F, Index, Q
+from django.db.models.functions import Cast, Collate, Length, Lower
+from django.test import skipUnlessDBFeature
+from django.test.utils import register_lookup
+
+from . import PostgreSQLSimpleTestCase, PostgreSQLTestCase
+from .fields import SearchVector, SearchVectorField
+from .models import CharFieldModel, IntegerArrayModel, Scene, TextFieldModel
+
+
+class IndexTestMixin:
+ def test_name_auto_generation(self):
+ index = self.index_class(fields=["field"])
+ index.set_name_with_model(CharFieldModel)
+ self.assertRegex(
+ index.name, r"postgres_te_field_[0-9a-f]{6}_%s" % self.index_class.suffix
+ )
+
+ def test_deconstruction_no_customization(self):
+ index = self.index_class(
+ fields=["title"], name="test_title_%s" % self.index_class.suffix
+ )
+ path, args, kwargs = index.deconstruct()
+ self.assertEqual(
+ path, "django.contrib.postgres.indexes.%s" % self.index_class.__name__
+ )
+ self.assertEqual(args, ())
+ self.assertEqual(
+ kwargs,
+ {"fields": ["title"], "name": "test_title_%s" % self.index_class.suffix},
+ )
+
+ def test_deconstruction_with_expressions_no_customization(self):
+ name = f"test_title_{self.index_class.suffix}"
+ index = self.index_class(Lower("title"), name=name)
+ path, args, kwargs = index.deconstruct()
+ self.assertEqual(
+ path,
+ f"django.contrib.postgres.indexes.{self.index_class.__name__}",
+ )
+ self.assertEqual(args, (Lower("title"),))
+ self.assertEqual(kwargs, {"name": name})
+
+
+class BloomIndexTests(IndexTestMixin, PostgreSQLSimpleTestCase):
+ index_class = BloomIndex
+
+ def test_suffix(self):
+ self.assertEqual(BloomIndex.suffix, "bloom")
+
+ def test_deconstruction(self):
+ index = BloomIndex(fields=["title"], name="test_bloom", length=80, columns=[4])
+ path, args, kwargs = index.deconstruct()
+ self.assertEqual(path, "django.contrib.postgres.indexes.BloomIndex")
+ self.assertEqual(args, ())
+ self.assertEqual(
+ kwargs,
+ {
+ "fields": ["title"],
+ "name": "test_bloom",
+ "length": 80,
+ "columns": [4],
+ },
+ )
+
+ def test_invalid_fields(self):
+ msg = "Bloom indexes support a maximum of 32 fields."
+ with self.assertRaisesMessage(ValueError, msg):
+ BloomIndex(fields=["title"] * 33, name="test_bloom")
+
+ def test_invalid_columns(self):
+ msg = "BloomIndex.columns must be a list or tuple."
+ with self.assertRaisesMessage(ValueError, msg):
+ BloomIndex(fields=["title"], name="test_bloom", columns="x")
+ msg = "BloomIndex.columns cannot have more values than fields."
+ with self.assertRaisesMessage(ValueError, msg):
+ BloomIndex(fields=["title"], name="test_bloom", columns=[4, 3])
+
+ def test_invalid_columns_value(self):
+ msg = "BloomIndex.columns must contain integers from 1 to 4095."
+ for length in (0, 4096):
+ with self.subTest(length), self.assertRaisesMessage(ValueError, msg):
+ BloomIndex(fields=["title"], name="test_bloom", columns=[length])
+
+ def test_invalid_length(self):
+ msg = "BloomIndex.length must be None or an integer from 1 to 4096."
+ for length in (0, 4097):
+ with self.subTest(length), self.assertRaisesMessage(ValueError, msg):
+ BloomIndex(fields=["title"], name="test_bloom", length=length)
+
+
+class BrinIndexTests(IndexTestMixin, PostgreSQLSimpleTestCase):
+ index_class = BrinIndex
+
+ def test_suffix(self):
+ self.assertEqual(BrinIndex.suffix, "brin")
+
+ def test_deconstruction(self):
+ index = BrinIndex(
+ fields=["title"],
+ name="test_title_brin",
+ autosummarize=True,
+ pages_per_range=16,
+ )
+ path, args, kwargs = index.deconstruct()
+ self.assertEqual(path, "django.contrib.postgres.indexes.BrinIndex")
+ self.assertEqual(args, ())
+ self.assertEqual(
+ kwargs,
+ {
+ "fields": ["title"],
+ "name": "test_title_brin",
+ "autosummarize": True,
+ "pages_per_range": 16,
+ },
+ )
+
+ def test_invalid_pages_per_range(self):
+ with self.assertRaisesMessage(
+ ValueError, "pages_per_range must be None or a positive integer"
+ ):
+ BrinIndex(fields=["title"], name="test_title_brin", pages_per_range=0)
+
+
+class BTreeIndexTests(IndexTestMixin, PostgreSQLSimpleTestCase):
+ index_class = BTreeIndex
+
+ def test_suffix(self):
+ self.assertEqual(BTreeIndex.suffix, "btree")
+
+ def test_deconstruction(self):
+ index = BTreeIndex(fields=["title"], name="test_title_btree", fillfactor=80)
+ path, args, kwargs = index.deconstruct()
+ self.assertEqual(path, "django.contrib.postgres.indexes.BTreeIndex")
+ self.assertEqual(args, ())
+ self.assertEqual(
+ kwargs, {"fields": ["title"], "name": "test_title_btree", "fillfactor": 80}
+ )
+
+
+class GinIndexTests(IndexTestMixin, PostgreSQLSimpleTestCase):
+ index_class = GinIndex
+
+ def test_suffix(self):
+ self.assertEqual(GinIndex.suffix, "gin")
+
+ def test_deconstruction(self):
+ index = GinIndex(
+ fields=["title"],
+ name="test_title_gin",
+ fastupdate=True,
+ gin_pending_list_limit=128,
+ )
+ path, args, kwargs = index.deconstruct()
+ self.assertEqual(path, "django.contrib.postgres.indexes.GinIndex")
+ self.assertEqual(args, ())
+ self.assertEqual(
+ kwargs,
+ {
+ "fields": ["title"],
+ "name": "test_title_gin",
+ "fastupdate": True,
+ "gin_pending_list_limit": 128,
+ },
+ )
+
+
+class GistIndexTests(IndexTestMixin, PostgreSQLSimpleTestCase):
+ index_class = GistIndex
+
+ def test_suffix(self):
+ self.assertEqual(GistIndex.suffix, "gist")
+
+ def test_deconstruction(self):
+ index = GistIndex(
+ fields=["title"], name="test_title_gist", buffering=False, fillfactor=80
+ )
+ path, args, kwargs = index.deconstruct()
+ self.assertEqual(path, "django.contrib.postgres.indexes.GistIndex")
+ self.assertEqual(args, ())
+ self.assertEqual(
+ kwargs,
+ {
+ "fields": ["title"],
+ "name": "test_title_gist",
+ "buffering": False,
+ "fillfactor": 80,
+ },
+ )
+
+
+class HashIndexTests(IndexTestMixin, PostgreSQLSimpleTestCase):
+ index_class = HashIndex
+
+ def test_suffix(self):
+ self.assertEqual(HashIndex.suffix, "hash")
+
+ def test_deconstruction(self):
+ index = HashIndex(fields=["title"], name="test_title_hash", fillfactor=80)
+ path, args, kwargs = index.deconstruct()
+ self.assertEqual(path, "django.contrib.postgres.indexes.HashIndex")
+ self.assertEqual(args, ())
+ self.assertEqual(
+ kwargs, {"fields": ["title"], "name": "test_title_hash", "fillfactor": 80}
+ )
+
+
+class SpGistIndexTests(IndexTestMixin, PostgreSQLSimpleTestCase):
+ index_class = SpGistIndex
+
+ def test_suffix(self):
+ self.assertEqual(SpGistIndex.suffix, "spgist")
+
+ def test_deconstruction(self):
+ index = SpGistIndex(fields=["title"], name="test_title_spgist", fillfactor=80)
+ path, args, kwargs = index.deconstruct()
+ self.assertEqual(path, "django.contrib.postgres.indexes.SpGistIndex")
+ self.assertEqual(args, ())
+ self.assertEqual(
+ kwargs, {"fields": ["title"], "name": "test_title_spgist", "fillfactor": 80}
+ )
+
+
+class SchemaTests(PostgreSQLTestCase):
+ 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 get_constraints(self, table):
+ """
+ Get the indexes on the table using a new cursor.
+ """
+ with connection.cursor() as cursor:
+ return connection.introspection.get_constraints(cursor, table)
+
+ def test_gin_index(self):
+ # Ensure the table is there and doesn't have an index.
+ self.assertNotIn(
+ "field", self.get_constraints(IntegerArrayModel._meta.db_table)
+ )
+ # Add the index
+ index_name = "integer_array_model_field_gin"
+ index = GinIndex(fields=["field"], name=index_name)
+ with connection.schema_editor() as editor:
+ editor.add_index(IntegerArrayModel, index)
+ constraints = self.get_constraints(IntegerArrayModel._meta.db_table)
+ # Check gin index was added
+ self.assertEqual(constraints[index_name]["type"], GinIndex.suffix)
+ # Drop the index
+ with connection.schema_editor() as editor:
+ editor.remove_index(IntegerArrayModel, index)
+ self.assertNotIn(
+ index_name, self.get_constraints(IntegerArrayModel._meta.db_table)
+ )
+
+ def test_gin_fastupdate(self):
+ index_name = "integer_array_gin_fastupdate"
+ index = GinIndex(fields=["field"], name=index_name, fastupdate=False)
+ with connection.schema_editor() as editor:
+ editor.add_index(IntegerArrayModel, index)
+ constraints = self.get_constraints(IntegerArrayModel._meta.db_table)
+ self.assertEqual(constraints[index_name]["type"], "gin")
+ self.assertEqual(constraints[index_name]["options"], ["fastupdate=off"])
+ with connection.schema_editor() as editor:
+ editor.remove_index(IntegerArrayModel, index)
+ self.assertNotIn(
+ index_name, self.get_constraints(IntegerArrayModel._meta.db_table)
+ )
+
+ def test_partial_gin_index(self):
+ with register_lookup(CharField, Length):
+ index_name = "char_field_gin_partial_idx"
+ index = GinIndex(
+ fields=["field"], name=index_name, condition=Q(field__length=40)
+ )
+ with connection.schema_editor() as editor:
+ editor.add_index(CharFieldModel, index)
+ constraints = self.get_constraints(CharFieldModel._meta.db_table)
+ self.assertEqual(constraints[index_name]["type"], "gin")
+ with connection.schema_editor() as editor:
+ editor.remove_index(CharFieldModel, index)
+ self.assertNotIn(
+ index_name, self.get_constraints(CharFieldModel._meta.db_table)
+ )
+
+ def test_partial_gin_index_with_tablespace(self):
+ with register_lookup(CharField, Length):
+ index_name = "char_field_gin_partial_idx"
+ index = GinIndex(
+ fields=["field"],
+ name=index_name,
+ condition=Q(field__length=40),
+ db_tablespace="pg_default",
+ )
+ with connection.schema_editor() as editor:
+ editor.add_index(CharFieldModel, index)
+ self.assertIn(
+ 'TABLESPACE "pg_default" ',
+ str(index.create_sql(CharFieldModel, editor)),
+ )
+ constraints = self.get_constraints(CharFieldModel._meta.db_table)
+ self.assertEqual(constraints[index_name]["type"], "gin")
+ with connection.schema_editor() as editor:
+ editor.remove_index(CharFieldModel, index)
+ self.assertNotIn(
+ index_name, self.get_constraints(CharFieldModel._meta.db_table)
+ )
+
+ def test_gin_parameters(self):
+ index_name = "integer_array_gin_params"
+ index = GinIndex(
+ fields=["field"],
+ name=index_name,
+ fastupdate=True,
+ gin_pending_list_limit=64,
+ db_tablespace="pg_default",
+ )
+ with connection.schema_editor() as editor:
+ editor.add_index(IntegerArrayModel, index)
+ self.assertIn(
+ ") WITH (gin_pending_list_limit = 64, fastupdate = on) TABLESPACE",
+ str(index.create_sql(IntegerArrayModel, editor)),
+ )
+ constraints = self.get_constraints(IntegerArrayModel._meta.db_table)
+ self.assertEqual(constraints[index_name]["type"], "gin")
+ self.assertEqual(
+ constraints[index_name]["options"],
+ ["gin_pending_list_limit=64", "fastupdate=on"],
+ )
+ with connection.schema_editor() as editor:
+ editor.remove_index(IntegerArrayModel, index)
+ self.assertNotIn(
+ index_name, self.get_constraints(IntegerArrayModel._meta.db_table)
+ )
+
+ def test_trigram_op_class_gin_index(self):
+ index_name = "trigram_op_class_gin"
+ index = GinIndex(OpClass(F("scene"), name="gin_trgm_ops"), name=index_name)
+ with connection.schema_editor() as editor:
+ editor.add_index(Scene, index)
+ with editor.connection.cursor() as cursor:
+ cursor.execute(self.get_opclass_query, [index_name])
+ self.assertCountEqual(cursor.fetchall(), [("gin_trgm_ops", index_name)])
+ constraints = self.get_constraints(Scene._meta.db_table)
+ self.assertIn(index_name, constraints)
+ self.assertIn(constraints[index_name]["type"], GinIndex.suffix)
+ with connection.schema_editor() as editor:
+ editor.remove_index(Scene, index)
+ self.assertNotIn(index_name, self.get_constraints(Scene._meta.db_table))
+
+ def test_cast_search_vector_gin_index(self):
+ index_name = "cast_search_vector_gin"
+ index = GinIndex(Cast("field", SearchVectorField()), name=index_name)
+ with connection.schema_editor() as editor:
+ editor.add_index(TextFieldModel, index)
+ sql = index.create_sql(TextFieldModel, editor)
+ table = TextFieldModel._meta.db_table
+ constraints = self.get_constraints(table)
+ self.assertIn(index_name, constraints)
+ self.assertIn(constraints[index_name]["type"], GinIndex.suffix)
+ self.assertIs(sql.references_column(table, "field"), True)
+ self.assertIn("::tsvector", str(sql))
+ with connection.schema_editor() as editor:
+ editor.remove_index(TextFieldModel, index)
+ self.assertNotIn(index_name, self.get_constraints(table))
+
+ def test_bloom_index(self):
+ index_name = "char_field_model_field_bloom"
+ index = BloomIndex(fields=["field"], name=index_name)
+ with connection.schema_editor() as editor:
+ editor.add_index(CharFieldModel, index)
+ constraints = self.get_constraints(CharFieldModel._meta.db_table)
+ self.assertEqual(constraints[index_name]["type"], BloomIndex.suffix)
+ with connection.schema_editor() as editor:
+ editor.remove_index(CharFieldModel, index)
+ self.assertNotIn(
+ index_name, self.get_constraints(CharFieldModel._meta.db_table)
+ )
+
+ def test_bloom_parameters(self):
+ index_name = "char_field_model_field_bloom_params"
+ index = BloomIndex(fields=["field"], name=index_name, length=512, columns=[3])
+ with connection.schema_editor() as editor:
+ editor.add_index(CharFieldModel, index)
+ constraints = self.get_constraints(CharFieldModel._meta.db_table)
+ self.assertEqual(constraints[index_name]["type"], BloomIndex.suffix)
+ self.assertEqual(constraints[index_name]["options"], ["length=512", "col1=3"])
+ with connection.schema_editor() as editor:
+ editor.remove_index(CharFieldModel, index)
+ self.assertNotIn(
+ index_name, self.get_constraints(CharFieldModel._meta.db_table)
+ )
+
+ def test_brin_index(self):
+ index_name = "char_field_model_field_brin"
+ index = BrinIndex(fields=["field"], name=index_name, pages_per_range=4)
+ with connection.schema_editor() as editor:
+ editor.add_index(CharFieldModel, index)
+ constraints = self.get_constraints(CharFieldModel._meta.db_table)
+ self.assertEqual(constraints[index_name]["type"], BrinIndex.suffix)
+ self.assertEqual(constraints[index_name]["options"], ["pages_per_range=4"])
+ with connection.schema_editor() as editor:
+ editor.remove_index(CharFieldModel, index)
+ self.assertNotIn(
+ index_name, self.get_constraints(CharFieldModel._meta.db_table)
+ )
+
+ def test_brin_parameters(self):
+ index_name = "char_field_brin_params"
+ index = BrinIndex(fields=["field"], name=index_name, autosummarize=True)
+ with connection.schema_editor() as editor:
+ editor.add_index(CharFieldModel, index)
+ constraints = self.get_constraints(CharFieldModel._meta.db_table)
+ self.assertEqual(constraints[index_name]["type"], BrinIndex.suffix)
+ self.assertEqual(constraints[index_name]["options"], ["autosummarize=on"])
+ with connection.schema_editor() as editor:
+ editor.remove_index(CharFieldModel, index)
+ self.assertNotIn(
+ index_name, self.get_constraints(CharFieldModel._meta.db_table)
+ )
+
+ def test_btree_index(self):
+ # Ensure the table is there and doesn't have an index.
+ self.assertNotIn("field", self.get_constraints(CharFieldModel._meta.db_table))
+ # Add the index.
+ index_name = "char_field_model_field_btree"
+ index = BTreeIndex(fields=["field"], name=index_name)
+ with connection.schema_editor() as editor:
+ editor.add_index(CharFieldModel, index)
+ constraints = self.get_constraints(CharFieldModel._meta.db_table)
+ # The index was added.
+ self.assertEqual(constraints[index_name]["type"], BTreeIndex.suffix)
+ # Drop the index.
+ with connection.schema_editor() as editor:
+ editor.remove_index(CharFieldModel, index)
+ self.assertNotIn(
+ index_name, self.get_constraints(CharFieldModel._meta.db_table)
+ )
+
+ def test_btree_parameters(self):
+ index_name = "integer_array_btree_fillfactor"
+ index = BTreeIndex(fields=["field"], name=index_name, fillfactor=80)
+ with connection.schema_editor() as editor:
+ editor.add_index(CharFieldModel, index)
+ constraints = self.get_constraints(CharFieldModel._meta.db_table)
+ self.assertEqual(constraints[index_name]["type"], BTreeIndex.suffix)
+ self.assertEqual(constraints[index_name]["options"], ["fillfactor=80"])
+ with connection.schema_editor() as editor:
+ editor.remove_index(CharFieldModel, index)
+ self.assertNotIn(
+ index_name, self.get_constraints(CharFieldModel._meta.db_table)
+ )
+
+ def test_gist_index(self):
+ # Ensure the table is there and doesn't have an index.
+ self.assertNotIn("field", self.get_constraints(CharFieldModel._meta.db_table))
+ # Add the index.
+ index_name = "char_field_model_field_gist"
+ index = GistIndex(fields=["field"], name=index_name)
+ with connection.schema_editor() as editor:
+ editor.add_index(CharFieldModel, index)
+ constraints = self.get_constraints(CharFieldModel._meta.db_table)
+ # The index was added.
+ self.assertEqual(constraints[index_name]["type"], GistIndex.suffix)
+ # Drop the index.
+ with connection.schema_editor() as editor:
+ editor.remove_index(CharFieldModel, index)
+ self.assertNotIn(
+ index_name, self.get_constraints(CharFieldModel._meta.db_table)
+ )
+
+ def test_gist_parameters(self):
+ index_name = "integer_array_gist_buffering"
+ index = GistIndex(
+ fields=["field"], name=index_name, buffering=True, fillfactor=80
+ )
+ with connection.schema_editor() as editor:
+ editor.add_index(CharFieldModel, index)
+ constraints = self.get_constraints(CharFieldModel._meta.db_table)
+ self.assertEqual(constraints[index_name]["type"], GistIndex.suffix)
+ self.assertEqual(
+ constraints[index_name]["options"], ["buffering=on", "fillfactor=80"]
+ )
+ with connection.schema_editor() as editor:
+ editor.remove_index(CharFieldModel, index)
+ self.assertNotIn(
+ index_name, self.get_constraints(CharFieldModel._meta.db_table)
+ )
+
+ def test_gist_include(self):
+ index_name = "scene_gist_include_setting"
+ index = GistIndex(name=index_name, fields=["scene"], include=["setting"])
+ with connection.schema_editor() as editor:
+ editor.add_index(Scene, index)
+ constraints = self.get_constraints(Scene._meta.db_table)
+ self.assertIn(index_name, constraints)
+ self.assertEqual(constraints[index_name]["type"], GistIndex.suffix)
+ self.assertEqual(constraints[index_name]["columns"], ["scene", "setting"])
+ with connection.schema_editor() as editor:
+ editor.remove_index(Scene, index)
+ self.assertNotIn(index_name, self.get_constraints(Scene._meta.db_table))
+
+ def test_tsvector_op_class_gist_index(self):
+ index_name = "tsvector_op_class_gist"
+ index = GistIndex(
+ OpClass(
+ SearchVector("scene", "setting", config="english"),
+ name="tsvector_ops",
+ ),
+ name=index_name,
+ )
+ with connection.schema_editor() as editor:
+ editor.add_index(Scene, index)
+ sql = index.create_sql(Scene, editor)
+ table = Scene._meta.db_table
+ constraints = self.get_constraints(table)
+ self.assertIn(index_name, constraints)
+ self.assertIn(constraints[index_name]["type"], GistIndex.suffix)
+ self.assertIs(sql.references_column(table, "scene"), True)
+ self.assertIs(sql.references_column(table, "setting"), True)
+ with connection.schema_editor() as editor:
+ editor.remove_index(Scene, index)
+ self.assertNotIn(index_name, self.get_constraints(table))
+
+ def test_search_vector(self):
+ """SearchVector generates IMMUTABLE SQL in order to be indexable."""
+ index_name = "test_search_vector"
+ index = Index(SearchVector("id", "scene", config="english"), name=index_name)
+ # Indexed function must be IMMUTABLE.
+ with connection.schema_editor() as editor:
+ editor.add_index(Scene, index)
+ constraints = self.get_constraints(Scene._meta.db_table)
+ self.assertIn(index_name, constraints)
+ self.assertIs(constraints[index_name]["index"], True)
+
+ with connection.schema_editor() as editor:
+ editor.remove_index(Scene, index)
+ self.assertNotIn(index_name, self.get_constraints(Scene._meta.db_table))
+
+ def test_hash_index(self):
+ # Ensure the table is there and doesn't have an index.
+ self.assertNotIn("field", self.get_constraints(CharFieldModel._meta.db_table))
+ # Add the index.
+ index_name = "char_field_model_field_hash"
+ index = HashIndex(fields=["field"], name=index_name)
+ with connection.schema_editor() as editor:
+ editor.add_index(CharFieldModel, index)
+ constraints = self.get_constraints(CharFieldModel._meta.db_table)
+ # The index was added.
+ self.assertEqual(constraints[index_name]["type"], HashIndex.suffix)
+ # Drop the index.
+ with connection.schema_editor() as editor:
+ editor.remove_index(CharFieldModel, index)
+ self.assertNotIn(
+ index_name, self.get_constraints(CharFieldModel._meta.db_table)
+ )
+
+ def test_hash_parameters(self):
+ index_name = "integer_array_hash_fillfactor"
+ index = HashIndex(fields=["field"], name=index_name, fillfactor=80)
+ with connection.schema_editor() as editor:
+ editor.add_index(CharFieldModel, index)
+ constraints = self.get_constraints(CharFieldModel._meta.db_table)
+ self.assertEqual(constraints[index_name]["type"], HashIndex.suffix)
+ self.assertEqual(constraints[index_name]["options"], ["fillfactor=80"])
+ with connection.schema_editor() as editor:
+ editor.remove_index(CharFieldModel, index)
+ self.assertNotIn(
+ index_name, self.get_constraints(CharFieldModel._meta.db_table)
+ )
+
+ def test_spgist_index(self):
+ # Ensure the table is there and doesn't have an index.
+ self.assertNotIn("field", self.get_constraints(TextFieldModel._meta.db_table))
+ # Add the index.
+ index_name = "text_field_model_field_spgist"
+ index = SpGistIndex(fields=["field"], name=index_name)
+ with connection.schema_editor() as editor:
+ editor.add_index(TextFieldModel, index)
+ constraints = self.get_constraints(TextFieldModel._meta.db_table)
+ # The index was added.
+ self.assertEqual(constraints[index_name]["type"], SpGistIndex.suffix)
+ # Drop the index.
+ with connection.schema_editor() as editor:
+ editor.remove_index(TextFieldModel, index)
+ self.assertNotIn(
+ index_name, self.get_constraints(TextFieldModel._meta.db_table)
+ )
+
+ def test_spgist_parameters(self):
+ index_name = "text_field_model_spgist_fillfactor"
+ index = SpGistIndex(fields=["field"], name=index_name, fillfactor=80)
+ with connection.schema_editor() as editor:
+ editor.add_index(TextFieldModel, index)
+ constraints = self.get_constraints(TextFieldModel._meta.db_table)
+ self.assertEqual(constraints[index_name]["type"], SpGistIndex.suffix)
+ self.assertEqual(constraints[index_name]["options"], ["fillfactor=80"])
+ with connection.schema_editor() as editor:
+ editor.remove_index(TextFieldModel, index)
+ self.assertNotIn(
+ index_name, self.get_constraints(TextFieldModel._meta.db_table)
+ )
+
+ @skipUnlessDBFeature("supports_covering_spgist_indexes")
+ def test_spgist_include(self):
+ index_name = "scene_spgist_include_setting"
+ index = SpGistIndex(name=index_name, fields=["scene"], include=["setting"])
+ with connection.schema_editor() as editor:
+ editor.add_index(Scene, index)
+ constraints = self.get_constraints(Scene._meta.db_table)
+ self.assertIn(index_name, constraints)
+ self.assertEqual(constraints[index_name]["type"], SpGistIndex.suffix)
+ self.assertEqual(constraints[index_name]["columns"], ["scene", "setting"])
+ with connection.schema_editor() as editor:
+ editor.remove_index(Scene, index)
+ self.assertNotIn(index_name, self.get_constraints(Scene._meta.db_table))
+
+ def test_spgist_include_not_supported(self):
+ index_name = "spgist_include_exception"
+ index = SpGistIndex(fields=["scene"], name=index_name, include=["setting"])
+ msg = "Covering SP-GiST indexes require PostgreSQL 14+."
+ with self.assertRaisesMessage(NotSupportedError, msg):
+ with mock.patch(
+ "django.db.backends.postgresql.features.DatabaseFeatures."
+ "supports_covering_spgist_indexes",
+ False,
+ ):
+ with connection.schema_editor() as editor:
+ editor.add_index(Scene, index)
+ self.assertNotIn(index_name, self.get_constraints(Scene._meta.db_table))
+
+ def test_custom_suffix(self):
+ class CustomSuffixIndex(PostgresIndex):
+ suffix = "sfx"
+
+ def create_sql(self, model, schema_editor, using="gin", **kwargs):
+ return super().create_sql(model, schema_editor, using=using, **kwargs)
+
+ index = CustomSuffixIndex(fields=["field"], name="custom_suffix_idx")
+ self.assertEqual(index.suffix, "sfx")
+ with connection.schema_editor() as editor:
+ self.assertIn(
+ " USING gin ",
+ str(index.create_sql(CharFieldModel, editor)),
+ )
+
+ def test_op_class(self):
+ index_name = "test_op_class"
+ index = Index(
+ OpClass(Lower("field"), name="text_pattern_ops"),
+ name=index_name,
+ )
+ with connection.schema_editor() as editor:
+ editor.add_index(TextFieldModel, index)
+ 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_op_class_descending_collation(self):
+ collation = connection.features.test_collations.get("non_default")
+ if not collation:
+ self.skipTest("This backend does not support case-insensitive collations.")
+ index_name = "test_op_class_descending_collation"
+ index = Index(
+ Collate(
+ OpClass(Lower("field"), name="text_pattern_ops").desc(nulls_last=True),
+ collation=collation,
+ ),
+ name=index_name,
+ )
+ with connection.schema_editor() as editor:
+ editor.add_index(TextFieldModel, index)
+ self.assertIn(
+ "COLLATE %s" % editor.quote_name(collation),
+ str(index.create_sql(TextFieldModel, editor)),
+ )
+ with editor.connection.cursor() as cursor:
+ cursor.execute(self.get_opclass_query, [index_name])
+ self.assertCountEqual(cursor.fetchall(), [("text_pattern_ops", index_name)])
+ table = TextFieldModel._meta.db_table
+ constraints = self.get_constraints(table)
+ self.assertIn(index_name, constraints)
+ self.assertEqual(constraints[index_name]["orders"], ["DESC"])
+ with connection.schema_editor() as editor:
+ editor.remove_index(TextFieldModel, index)
+ self.assertNotIn(index_name, self.get_constraints(table))
+
+ def test_op_class_descending_partial(self):
+ index_name = "test_op_class_descending_partial"
+ index = Index(
+ OpClass(Lower("field"), name="text_pattern_ops").desc(),
+ name=index_name,
+ condition=Q(field__contains="China"),
+ )
+ with connection.schema_editor() as editor:
+ editor.add_index(TextFieldModel, index)
+ with editor.connection.cursor() as cursor:
+ cursor.execute(self.get_opclass_query, [index_name])
+ self.assertCountEqual(cursor.fetchall(), [("text_pattern_ops", index_name)])
+ constraints = self.get_constraints(TextFieldModel._meta.db_table)
+ self.assertIn(index_name, constraints)
+ self.assertEqual(constraints[index_name]["orders"], ["DESC"])
+
+ def test_op_class_descending_partial_tablespace(self):
+ index_name = "test_op_class_descending_partial_tablespace"
+ index = Index(
+ OpClass(Lower("field").desc(), name="text_pattern_ops"),
+ name=index_name,
+ condition=Q(field__contains="China"),
+ db_tablespace="pg_default",
+ )
+ with connection.schema_editor() as editor:
+ editor.add_index(TextFieldModel, index)
+ self.assertIn(
+ 'TABLESPACE "pg_default" ',
+ str(index.create_sql(TextFieldModel, editor)),
+ )
+ with editor.connection.cursor() as cursor:
+ cursor.execute(self.get_opclass_query, [index_name])
+ self.assertCountEqual(cursor.fetchall(), [("text_pattern_ops", index_name)])
+ constraints = self.get_constraints(TextFieldModel._meta.db_table)
+ self.assertIn(index_name, constraints)
+ self.assertEqual(constraints[index_name]["orders"], ["DESC"])
diff --git a/testbed/django__django/tests/postgres_tests/test_integration.py b/testbed/django__django/tests/postgres_tests/test_integration.py
new file mode 100644
index 0000000000000000000000000000000000000000..e3c62a93e9b84b9f4c701ea31205e15db69a0183
--- /dev/null
+++ b/testbed/django__django/tests/postgres_tests/test_integration.py
@@ -0,0 +1,29 @@
+import os
+import subprocess
+import sys
+
+from . import PostgreSQLSimpleTestCase
+
+
+class PostgresIntegrationTests(PostgreSQLSimpleTestCase):
+ def test_check(self):
+ test_environ = os.environ.copy()
+ if "DJANGO_SETTINGS_MODULE" in test_environ:
+ del test_environ["DJANGO_SETTINGS_MODULE"]
+ test_environ["PYTHONPATH"] = os.path.join(os.path.dirname(__file__), "../../")
+ result = subprocess.run(
+ [
+ sys.executable,
+ "-m",
+ "django",
+ "check",
+ "--settings",
+ "integration_settings",
+ ],
+ stdout=subprocess.DEVNULL,
+ stderr=subprocess.PIPE,
+ cwd=os.path.dirname(__file__),
+ env=test_environ,
+ encoding="utf-8",
+ )
+ self.assertEqual(result.returncode, 0, msg=result.stderr)
diff --git a/testbed/django__django/tests/postgres_tests/test_introspection.py b/testbed/django__django/tests/postgres_tests/test_introspection.py
new file mode 100644
index 0000000000000000000000000000000000000000..73c426d1bafc0cdf084cda4d28241460caf52d21
--- /dev/null
+++ b/testbed/django__django/tests/postgres_tests/test_introspection.py
@@ -0,0 +1,35 @@
+from io import StringIO
+
+from django.core.management import call_command
+
+from . import PostgreSQLTestCase
+
+
+class InspectDBTests(PostgreSQLTestCase):
+ def assertFieldsInModel(self, model, field_outputs):
+ out = StringIO()
+ call_command(
+ "inspectdb",
+ table_name_filter=lambda tn: tn.startswith(model),
+ stdout=out,
+ )
+ output = out.getvalue()
+ for field_output in field_outputs:
+ self.assertIn(field_output, output)
+
+ def test_range_fields(self):
+ self.assertFieldsInModel(
+ "postgres_tests_rangesmodel",
+ [
+ "ints = django.contrib.postgres.fields.IntegerRangeField(blank=True, "
+ "null=True)",
+ "bigints = django.contrib.postgres.fields.BigIntegerRangeField("
+ "blank=True, null=True)",
+ "decimals = django.contrib.postgres.fields.DecimalRangeField("
+ "blank=True, null=True)",
+ "timestamps = django.contrib.postgres.fields.DateTimeRangeField("
+ "blank=True, null=True)",
+ "dates = django.contrib.postgres.fields.DateRangeField(blank=True, "
+ "null=True)",
+ ],
+ )
diff --git a/testbed/django__django/tests/postgres_tests/test_operations.py b/testbed/django__django/tests/postgres_tests/test_operations.py
new file mode 100644
index 0000000000000000000000000000000000000000..f395198533c948875ba866612cff46a83982a8ca
--- /dev/null
+++ b/testbed/django__django/tests/postgres_tests/test_operations.py
@@ -0,0 +1,560 @@
+import unittest
+
+from migrations.test_base import OperationTestBase
+
+from django.db import IntegrityError, NotSupportedError, connection, transaction
+from django.db.migrations.state import ProjectState
+from django.db.models import CheckConstraint, Index, Q, UniqueConstraint
+from django.db.utils import ProgrammingError
+from django.test import modify_settings, override_settings
+from django.test.utils import CaptureQueriesContext
+
+from . import PostgreSQLTestCase
+
+try:
+ from django.contrib.postgres.indexes import BrinIndex, BTreeIndex
+ from django.contrib.postgres.operations import (
+ AddConstraintNotValid,
+ AddIndexConcurrently,
+ BloomExtension,
+ CreateCollation,
+ CreateExtension,
+ RemoveCollation,
+ RemoveIndexConcurrently,
+ ValidateConstraint,
+ )
+except ImportError:
+ pass
+
+
+@unittest.skipUnless(connection.vendor == "postgresql", "PostgreSQL specific tests.")
+@modify_settings(INSTALLED_APPS={"append": "migrations"})
+class AddIndexConcurrentlyTests(OperationTestBase):
+ app_label = "test_add_concurrently"
+
+ def test_requires_atomic_false(self):
+ project_state = self.set_up_test_model(self.app_label)
+ new_state = project_state.clone()
+ operation = AddIndexConcurrently(
+ "Pony",
+ Index(fields=["pink"], name="pony_pink_idx"),
+ )
+ msg = (
+ "The AddIndexConcurrently operation cannot be executed inside "
+ "a transaction (set atomic = False on the migration)."
+ )
+ with self.assertRaisesMessage(NotSupportedError, msg):
+ with connection.schema_editor(atomic=True) as editor:
+ operation.database_forwards(
+ self.app_label, editor, project_state, new_state
+ )
+
+ def test_add(self):
+ project_state = self.set_up_test_model(self.app_label, index=False)
+ table_name = "%s_pony" % self.app_label
+ index = Index(fields=["pink"], name="pony_pink_idx")
+ new_state = project_state.clone()
+ operation = AddIndexConcurrently("Pony", index)
+ self.assertEqual(
+ operation.describe(),
+ "Concurrently create index pony_pink_idx on field(s) pink of model Pony",
+ )
+ operation.state_forwards(self.app_label, new_state)
+ self.assertEqual(
+ len(new_state.models[self.app_label, "pony"].options["indexes"]), 1
+ )
+ self.assertIndexNotExists(table_name, ["pink"])
+ # Add index.
+ with connection.schema_editor(atomic=False) as editor:
+ operation.database_forwards(
+ self.app_label, editor, project_state, new_state
+ )
+ self.assertIndexExists(table_name, ["pink"])
+ # Reversal.
+ with connection.schema_editor(atomic=False) as editor:
+ operation.database_backwards(
+ self.app_label, editor, new_state, project_state
+ )
+ self.assertIndexNotExists(table_name, ["pink"])
+ # Deconstruction.
+ name, args, kwargs = operation.deconstruct()
+ self.assertEqual(name, "AddIndexConcurrently")
+ self.assertEqual(args, [])
+ self.assertEqual(kwargs, {"model_name": "Pony", "index": index})
+
+ def test_add_other_index_type(self):
+ project_state = self.set_up_test_model(self.app_label, index=False)
+ table_name = "%s_pony" % self.app_label
+ new_state = project_state.clone()
+ operation = AddIndexConcurrently(
+ "Pony",
+ BrinIndex(fields=["pink"], name="pony_pink_brin_idx"),
+ )
+ self.assertIndexNotExists(table_name, ["pink"])
+ # Add index.
+ with connection.schema_editor(atomic=False) as editor:
+ operation.database_forwards(
+ self.app_label, editor, project_state, new_state
+ )
+ self.assertIndexExists(table_name, ["pink"], index_type="brin")
+ # Reversal.
+ with connection.schema_editor(atomic=False) as editor:
+ operation.database_backwards(
+ self.app_label, editor, new_state, project_state
+ )
+ self.assertIndexNotExists(table_name, ["pink"])
+
+ def test_add_with_options(self):
+ project_state = self.set_up_test_model(self.app_label, index=False)
+ table_name = "%s_pony" % self.app_label
+ new_state = project_state.clone()
+ index = BTreeIndex(fields=["pink"], name="pony_pink_btree_idx", fillfactor=70)
+ operation = AddIndexConcurrently("Pony", index)
+ self.assertIndexNotExists(table_name, ["pink"])
+ # Add index.
+ with connection.schema_editor(atomic=False) as editor:
+ operation.database_forwards(
+ self.app_label, editor, project_state, new_state
+ )
+ self.assertIndexExists(table_name, ["pink"], index_type="btree")
+ # Reversal.
+ with connection.schema_editor(atomic=False) as editor:
+ operation.database_backwards(
+ self.app_label, editor, new_state, project_state
+ )
+ self.assertIndexNotExists(table_name, ["pink"])
+
+
+@unittest.skipUnless(connection.vendor == "postgresql", "PostgreSQL specific tests.")
+@modify_settings(INSTALLED_APPS={"append": "migrations"})
+class RemoveIndexConcurrentlyTests(OperationTestBase):
+ app_label = "test_rm_concurrently"
+
+ def test_requires_atomic_false(self):
+ project_state = self.set_up_test_model(self.app_label, index=True)
+ new_state = project_state.clone()
+ operation = RemoveIndexConcurrently("Pony", "pony_pink_idx")
+ msg = (
+ "The RemoveIndexConcurrently operation cannot be executed inside "
+ "a transaction (set atomic = False on the migration)."
+ )
+ with self.assertRaisesMessage(NotSupportedError, msg):
+ with connection.schema_editor(atomic=True) as editor:
+ operation.database_forwards(
+ self.app_label, editor, project_state, new_state
+ )
+
+ def test_remove(self):
+ project_state = self.set_up_test_model(self.app_label, index=True)
+ table_name = "%s_pony" % self.app_label
+ self.assertTableExists(table_name)
+ new_state = project_state.clone()
+ operation = RemoveIndexConcurrently("Pony", "pony_pink_idx")
+ self.assertEqual(
+ operation.describe(),
+ "Concurrently remove index pony_pink_idx from Pony",
+ )
+ operation.state_forwards(self.app_label, new_state)
+ self.assertEqual(
+ len(new_state.models[self.app_label, "pony"].options["indexes"]), 0
+ )
+ self.assertIndexExists(table_name, ["pink"])
+ # Remove index.
+ with connection.schema_editor(atomic=False) as editor:
+ operation.database_forwards(
+ self.app_label, editor, project_state, new_state
+ )
+ self.assertIndexNotExists(table_name, ["pink"])
+ # Reversal.
+ with connection.schema_editor(atomic=False) as editor:
+ operation.database_backwards(
+ self.app_label, editor, new_state, project_state
+ )
+ self.assertIndexExists(table_name, ["pink"])
+ # Deconstruction.
+ name, args, kwargs = operation.deconstruct()
+ self.assertEqual(name, "RemoveIndexConcurrently")
+ self.assertEqual(args, [])
+ self.assertEqual(kwargs, {"model_name": "Pony", "name": "pony_pink_idx"})
+
+
+class NoMigrationRouter:
+ def allow_migrate(self, db, app_label, **hints):
+ return False
+
+
+@unittest.skipUnless(connection.vendor == "postgresql", "PostgreSQL specific tests.")
+class CreateExtensionTests(PostgreSQLTestCase):
+ app_label = "test_allow_create_extention"
+
+ @override_settings(DATABASE_ROUTERS=[NoMigrationRouter()])
+ def test_no_allow_migrate(self):
+ operation = CreateExtension("tablefunc")
+ project_state = ProjectState()
+ new_state = project_state.clone()
+ # Don't create an extension.
+ with CaptureQueriesContext(connection) as captured_queries:
+ with connection.schema_editor(atomic=False) as editor:
+ operation.database_forwards(
+ self.app_label, editor, project_state, new_state
+ )
+ self.assertEqual(len(captured_queries), 0)
+ # Reversal.
+ with CaptureQueriesContext(connection) as captured_queries:
+ with connection.schema_editor(atomic=False) as editor:
+ operation.database_backwards(
+ self.app_label, editor, new_state, project_state
+ )
+ self.assertEqual(len(captured_queries), 0)
+
+ def test_allow_migrate(self):
+ operation = CreateExtension("tablefunc")
+ self.assertEqual(
+ operation.migration_name_fragment, "create_extension_tablefunc"
+ )
+ project_state = ProjectState()
+ new_state = project_state.clone()
+ # Create an extension.
+ with CaptureQueriesContext(connection) as captured_queries:
+ with connection.schema_editor(atomic=False) as editor:
+ operation.database_forwards(
+ self.app_label, editor, project_state, new_state
+ )
+ self.assertEqual(len(captured_queries), 4)
+ self.assertIn("CREATE EXTENSION IF NOT EXISTS", captured_queries[1]["sql"])
+ # Reversal.
+ with CaptureQueriesContext(connection) as captured_queries:
+ with connection.schema_editor(atomic=False) as editor:
+ operation.database_backwards(
+ self.app_label, editor, new_state, project_state
+ )
+ self.assertEqual(len(captured_queries), 2)
+ self.assertIn("DROP EXTENSION IF EXISTS", captured_queries[1]["sql"])
+
+ def test_create_existing_extension(self):
+ operation = BloomExtension()
+ self.assertEqual(operation.migration_name_fragment, "create_extension_bloom")
+ project_state = ProjectState()
+ new_state = project_state.clone()
+ # Don't create an existing extension.
+ with CaptureQueriesContext(connection) as captured_queries:
+ with connection.schema_editor(atomic=False) as editor:
+ operation.database_forwards(
+ self.app_label, editor, project_state, new_state
+ )
+ self.assertEqual(len(captured_queries), 3)
+ self.assertIn("SELECT", captured_queries[0]["sql"])
+
+ def test_drop_nonexistent_extension(self):
+ operation = CreateExtension("tablefunc")
+ project_state = ProjectState()
+ new_state = project_state.clone()
+ # Don't drop a nonexistent extension.
+ with CaptureQueriesContext(connection) as captured_queries:
+ with connection.schema_editor(atomic=False) as editor:
+ operation.database_backwards(
+ self.app_label, editor, project_state, new_state
+ )
+ self.assertEqual(len(captured_queries), 1)
+ self.assertIn("SELECT", captured_queries[0]["sql"])
+
+
+@unittest.skipUnless(connection.vendor == "postgresql", "PostgreSQL specific tests.")
+class CreateCollationTests(PostgreSQLTestCase):
+ app_label = "test_allow_create_collation"
+
+ @override_settings(DATABASE_ROUTERS=[NoMigrationRouter()])
+ def test_no_allow_migrate(self):
+ operation = CreateCollation("C_test", locale="C")
+ project_state = ProjectState()
+ new_state = project_state.clone()
+ # Don't create a collation.
+ with CaptureQueriesContext(connection) as captured_queries:
+ with connection.schema_editor(atomic=False) as editor:
+ operation.database_forwards(
+ self.app_label, editor, project_state, new_state
+ )
+ self.assertEqual(len(captured_queries), 0)
+ # Reversal.
+ with CaptureQueriesContext(connection) as captured_queries:
+ with connection.schema_editor(atomic=False) as editor:
+ operation.database_backwards(
+ self.app_label, editor, new_state, project_state
+ )
+ self.assertEqual(len(captured_queries), 0)
+
+ def test_create(self):
+ operation = CreateCollation("C_test", locale="C")
+ self.assertEqual(operation.migration_name_fragment, "create_collation_c_test")
+ self.assertEqual(operation.describe(), "Create collation C_test")
+ project_state = ProjectState()
+ new_state = project_state.clone()
+ # Create a collation.
+ with CaptureQueriesContext(connection) as captured_queries:
+ with connection.schema_editor(atomic=False) as editor:
+ operation.database_forwards(
+ self.app_label, editor, project_state, new_state
+ )
+ self.assertEqual(len(captured_queries), 1)
+ self.assertIn("CREATE COLLATION", captured_queries[0]["sql"])
+ # Creating the same collation raises an exception.
+ with self.assertRaisesMessage(ProgrammingError, "already exists"):
+ with connection.schema_editor(atomic=True) as editor:
+ operation.database_forwards(
+ self.app_label, editor, project_state, new_state
+ )
+ # Reversal.
+ with CaptureQueriesContext(connection) as captured_queries:
+ with connection.schema_editor(atomic=False) as editor:
+ operation.database_backwards(
+ self.app_label, editor, new_state, project_state
+ )
+ self.assertEqual(len(captured_queries), 1)
+ self.assertIn("DROP COLLATION", captured_queries[0]["sql"])
+ # Deconstruction.
+ name, args, kwargs = operation.deconstruct()
+ self.assertEqual(name, "CreateCollation")
+ self.assertEqual(args, [])
+ self.assertEqual(kwargs, {"name": "C_test", "locale": "C"})
+
+ def test_create_non_deterministic_collation(self):
+ operation = CreateCollation(
+ "case_insensitive_test",
+ "und-u-ks-level2",
+ provider="icu",
+ deterministic=False,
+ )
+ project_state = ProjectState()
+ new_state = project_state.clone()
+ # Create a collation.
+ with CaptureQueriesContext(connection) as captured_queries:
+ with connection.schema_editor(atomic=False) as editor:
+ operation.database_forwards(
+ self.app_label, editor, project_state, new_state
+ )
+ self.assertEqual(len(captured_queries), 1)
+ self.assertIn("CREATE COLLATION", captured_queries[0]["sql"])
+ # Reversal.
+ with CaptureQueriesContext(connection) as captured_queries:
+ with connection.schema_editor(atomic=False) as editor:
+ operation.database_backwards(
+ self.app_label, editor, new_state, project_state
+ )
+ self.assertEqual(len(captured_queries), 1)
+ self.assertIn("DROP COLLATION", captured_queries[0]["sql"])
+ # Deconstruction.
+ name, args, kwargs = operation.deconstruct()
+ self.assertEqual(name, "CreateCollation")
+ self.assertEqual(args, [])
+ self.assertEqual(
+ kwargs,
+ {
+ "name": "case_insensitive_test",
+ "locale": "und-u-ks-level2",
+ "provider": "icu",
+ "deterministic": False,
+ },
+ )
+
+ def test_create_collation_alternate_provider(self):
+ operation = CreateCollation(
+ "german_phonebook_test",
+ provider="icu",
+ locale="de-u-co-phonebk",
+ )
+ project_state = ProjectState()
+ new_state = project_state.clone()
+ # Create an collation.
+ with CaptureQueriesContext(connection) as captured_queries:
+ with connection.schema_editor(atomic=False) as editor:
+ operation.database_forwards(
+ self.app_label, editor, project_state, new_state
+ )
+ self.assertEqual(len(captured_queries), 1)
+ self.assertIn("CREATE COLLATION", captured_queries[0]["sql"])
+ # Reversal.
+ with CaptureQueriesContext(connection) as captured_queries:
+ with connection.schema_editor(atomic=False) as editor:
+ operation.database_backwards(
+ self.app_label, editor, new_state, project_state
+ )
+ self.assertEqual(len(captured_queries), 1)
+ self.assertIn("DROP COLLATION", captured_queries[0]["sql"])
+
+
+@unittest.skipUnless(connection.vendor == "postgresql", "PostgreSQL specific tests.")
+class RemoveCollationTests(PostgreSQLTestCase):
+ app_label = "test_allow_remove_collation"
+
+ @override_settings(DATABASE_ROUTERS=[NoMigrationRouter()])
+ def test_no_allow_migrate(self):
+ operation = RemoveCollation("C_test", locale="C")
+ project_state = ProjectState()
+ new_state = project_state.clone()
+ # Don't create a collation.
+ with CaptureQueriesContext(connection) as captured_queries:
+ with connection.schema_editor(atomic=False) as editor:
+ operation.database_forwards(
+ self.app_label, editor, project_state, new_state
+ )
+ self.assertEqual(len(captured_queries), 0)
+ # Reversal.
+ with CaptureQueriesContext(connection) as captured_queries:
+ with connection.schema_editor(atomic=False) as editor:
+ operation.database_backwards(
+ self.app_label, editor, new_state, project_state
+ )
+ self.assertEqual(len(captured_queries), 0)
+
+ def test_remove(self):
+ operation = CreateCollation("C_test", locale="C")
+ project_state = ProjectState()
+ new_state = project_state.clone()
+ with connection.schema_editor(atomic=False) as editor:
+ operation.database_forwards(
+ self.app_label, editor, project_state, new_state
+ )
+
+ operation = RemoveCollation("C_test", locale="C")
+ self.assertEqual(operation.migration_name_fragment, "remove_collation_c_test")
+ self.assertEqual(operation.describe(), "Remove collation C_test")
+ project_state = ProjectState()
+ new_state = project_state.clone()
+ # Remove a collation.
+ with CaptureQueriesContext(connection) as captured_queries:
+ with connection.schema_editor(atomic=False) as editor:
+ operation.database_forwards(
+ self.app_label, editor, project_state, new_state
+ )
+ self.assertEqual(len(captured_queries), 1)
+ self.assertIn("DROP COLLATION", captured_queries[0]["sql"])
+ # Removing a nonexistent collation raises an exception.
+ with self.assertRaisesMessage(ProgrammingError, "does not exist"):
+ with connection.schema_editor(atomic=True) as editor:
+ operation.database_forwards(
+ self.app_label, editor, project_state, new_state
+ )
+ # Reversal.
+ with CaptureQueriesContext(connection) as captured_queries:
+ with connection.schema_editor(atomic=False) as editor:
+ operation.database_backwards(
+ self.app_label, editor, new_state, project_state
+ )
+ self.assertEqual(len(captured_queries), 1)
+ self.assertIn("CREATE COLLATION", captured_queries[0]["sql"])
+ # Deconstruction.
+ name, args, kwargs = operation.deconstruct()
+ self.assertEqual(name, "RemoveCollation")
+ self.assertEqual(args, [])
+ self.assertEqual(kwargs, {"name": "C_test", "locale": "C"})
+
+
+@unittest.skipUnless(connection.vendor == "postgresql", "PostgreSQL specific tests.")
+@modify_settings(INSTALLED_APPS={"append": "migrations"})
+class AddConstraintNotValidTests(OperationTestBase):
+ app_label = "test_add_constraint_not_valid"
+
+ def test_non_check_constraint_not_supported(self):
+ constraint = UniqueConstraint(fields=["pink"], name="pony_pink_uniq")
+ msg = "AddConstraintNotValid.constraint must be a check constraint."
+ with self.assertRaisesMessage(TypeError, msg):
+ AddConstraintNotValid(model_name="pony", constraint=constraint)
+
+ def test_add(self):
+ table_name = f"{self.app_label}_pony"
+ constraint_name = "pony_pink_gte_check"
+ constraint = CheckConstraint(check=Q(pink__gte=4), name=constraint_name)
+ operation = AddConstraintNotValid("Pony", constraint=constraint)
+ project_state, new_state = self.make_test_state(self.app_label, operation)
+ self.assertEqual(
+ operation.describe(),
+ f"Create not valid constraint {constraint_name} on model Pony",
+ )
+ self.assertEqual(
+ operation.migration_name_fragment,
+ f"pony_{constraint_name}_not_valid",
+ )
+ self.assertEqual(
+ len(new_state.models[self.app_label, "pony"].options["constraints"]),
+ 1,
+ )
+ self.assertConstraintNotExists(table_name, constraint_name)
+ Pony = new_state.apps.get_model(self.app_label, "Pony")
+ self.assertEqual(len(Pony._meta.constraints), 1)
+ Pony.objects.create(pink=2, weight=1.0)
+ # Add constraint.
+ with connection.schema_editor(atomic=True) as editor:
+ operation.database_forwards(
+ self.app_label, editor, project_state, new_state
+ )
+ msg = f'check constraint "{constraint_name}"'
+ with self.assertRaisesMessage(IntegrityError, msg), transaction.atomic():
+ Pony.objects.create(pink=3, weight=1.0)
+ self.assertConstraintExists(table_name, constraint_name)
+ # Reversal.
+ with connection.schema_editor(atomic=True) as editor:
+ operation.database_backwards(
+ self.app_label, editor, project_state, new_state
+ )
+ self.assertConstraintNotExists(table_name, constraint_name)
+ Pony.objects.create(pink=3, weight=1.0)
+ # Deconstruction.
+ name, args, kwargs = operation.deconstruct()
+ self.assertEqual(name, "AddConstraintNotValid")
+ self.assertEqual(args, [])
+ self.assertEqual(kwargs, {"model_name": "Pony", "constraint": constraint})
+
+
+@unittest.skipUnless(connection.vendor == "postgresql", "PostgreSQL specific tests.")
+@modify_settings(INSTALLED_APPS={"append": "migrations"})
+class ValidateConstraintTests(OperationTestBase):
+ app_label = "test_validate_constraint"
+
+ def test_validate(self):
+ constraint_name = "pony_pink_gte_check"
+ constraint = CheckConstraint(check=Q(pink__gte=4), name=constraint_name)
+ operation = AddConstraintNotValid("Pony", constraint=constraint)
+ project_state, new_state = self.make_test_state(self.app_label, operation)
+ Pony = new_state.apps.get_model(self.app_label, "Pony")
+ obj = Pony.objects.create(pink=2, weight=1.0)
+ # Add constraint.
+ with connection.schema_editor(atomic=True) as editor:
+ operation.database_forwards(
+ self.app_label, editor, project_state, new_state
+ )
+ project_state = new_state
+ new_state = new_state.clone()
+ operation = ValidateConstraint("Pony", name=constraint_name)
+ operation.state_forwards(self.app_label, new_state)
+ self.assertEqual(
+ operation.describe(),
+ f"Validate constraint {constraint_name} on model Pony",
+ )
+ self.assertEqual(
+ operation.migration_name_fragment,
+ f"pony_validate_{constraint_name}",
+ )
+ # Validate constraint.
+ with connection.schema_editor(atomic=True) as editor:
+ msg = f'check constraint "{constraint_name}"'
+ with self.assertRaisesMessage(IntegrityError, msg):
+ operation.database_forwards(
+ self.app_label, editor, project_state, new_state
+ )
+ obj.pink = 5
+ obj.save()
+ with connection.schema_editor(atomic=True) as editor:
+ operation.database_forwards(
+ self.app_label, editor, project_state, new_state
+ )
+ # Reversal is a noop.
+ with connection.schema_editor() as editor:
+ with self.assertNumQueries(0):
+ operation.database_backwards(
+ self.app_label, editor, new_state, project_state
+ )
+ # Deconstruction.
+ name, args, kwargs = operation.deconstruct()
+ self.assertEqual(name, "ValidateConstraint")
+ self.assertEqual(args, [])
+ self.assertEqual(kwargs, {"model_name": "Pony", "name": constraint_name})
diff --git a/testbed/django__django/tests/postgres_tests/test_ranges.py b/testbed/django__django/tests/postgres_tests/test_ranges.py
new file mode 100644
index 0000000000000000000000000000000000000000..038e0233c42640b9c73f52adbe486d324f9b83d9
--- /dev/null
+++ b/testbed/django__django/tests/postgres_tests/test_ranges.py
@@ -0,0 +1,1109 @@
+import datetime
+import json
+from decimal import Decimal
+
+from django import forms
+from django.core import exceptions, serializers
+from django.db.models import DateField, DateTimeField, F, Func, Value
+from django.http import QueryDict
+from django.test import override_settings
+from django.test.utils import isolate_apps
+from django.utils import timezone
+
+from . import PostgreSQLSimpleTestCase, PostgreSQLTestCase
+from .models import (
+ BigAutoFieldModel,
+ PostgreSQLModel,
+ RangeLookupsModel,
+ RangesModel,
+ SmallAutoFieldModel,
+)
+
+try:
+ from django.contrib.postgres import fields as pg_fields
+ from django.contrib.postgres import forms as pg_forms
+ from django.contrib.postgres.validators import (
+ RangeMaxValueValidator,
+ RangeMinValueValidator,
+ )
+ from django.db.backends.postgresql.psycopg_any import (
+ DateRange,
+ DateTimeTZRange,
+ NumericRange,
+ )
+except ImportError:
+ pass
+
+
+@isolate_apps("postgres_tests")
+class BasicTests(PostgreSQLSimpleTestCase):
+ def test_get_field_display(self):
+ class Model(PostgreSQLModel):
+ field = pg_fields.IntegerRangeField(
+ choices=[
+ ["1-50", [((1, 25), "1-25"), ([26, 50], "26-50")]],
+ ((51, 100), "51-100"),
+ ],
+ )
+
+ tests = (
+ ((1, 25), "1-25"),
+ ([26, 50], "26-50"),
+ ((51, 100), "51-100"),
+ ((1, 2), "(1, 2)"),
+ ([1, 2], "[1, 2]"),
+ )
+ for value, display in tests:
+ with self.subTest(value=value, display=display):
+ instance = Model(field=value)
+ self.assertEqual(instance.get_field_display(), display)
+
+ def test_discrete_range_fields_unsupported_default_bounds(self):
+ discrete_range_types = [
+ pg_fields.BigIntegerRangeField,
+ pg_fields.IntegerRangeField,
+ pg_fields.DateRangeField,
+ ]
+ for field_type in discrete_range_types:
+ msg = f"Cannot use 'default_bounds' with {field_type.__name__}."
+ with self.assertRaisesMessage(TypeError, msg):
+ field_type(choices=[((51, 100), "51-100")], default_bounds="[]")
+
+ def test_continuous_range_fields_default_bounds(self):
+ continuous_range_types = [
+ pg_fields.DecimalRangeField,
+ pg_fields.DateTimeRangeField,
+ ]
+ for field_type in continuous_range_types:
+ field = field_type(choices=[((51, 100), "51-100")], default_bounds="[]")
+ self.assertEqual(field.default_bounds, "[]")
+
+ def test_invalid_default_bounds(self):
+ tests = [")]", ")[", "](", "])", "([", "[(", "x", "", None]
+ msg = "default_bounds must be one of '[)', '(]', '()', or '[]'."
+ for invalid_bounds in tests:
+ with self.assertRaisesMessage(ValueError, msg):
+ pg_fields.DecimalRangeField(default_bounds=invalid_bounds)
+
+ def test_deconstruct(self):
+ field = pg_fields.DecimalRangeField()
+ *_, kwargs = field.deconstruct()
+ self.assertEqual(kwargs, {})
+ field = pg_fields.DecimalRangeField(default_bounds="[]")
+ *_, kwargs = field.deconstruct()
+ self.assertEqual(kwargs, {"default_bounds": "[]"})
+
+
+class TestSaveLoad(PostgreSQLTestCase):
+ def test_all_fields(self):
+ now = timezone.now()
+ instance = RangesModel(
+ ints=NumericRange(0, 10),
+ bigints=NumericRange(10, 20),
+ decimals=NumericRange(20, 30),
+ timestamps=DateTimeTZRange(now - datetime.timedelta(hours=1), now),
+ dates=DateRange(now.date() - datetime.timedelta(days=1), now.date()),
+ )
+ instance.save()
+ loaded = RangesModel.objects.get()
+ self.assertEqual(instance.ints, loaded.ints)
+ self.assertEqual(instance.bigints, loaded.bigints)
+ self.assertEqual(instance.decimals, loaded.decimals)
+ self.assertEqual(instance.timestamps, loaded.timestamps)
+ self.assertEqual(instance.dates, loaded.dates)
+
+ def test_range_object(self):
+ r = NumericRange(0, 10)
+ instance = RangesModel(ints=r)
+ instance.save()
+ loaded = RangesModel.objects.get()
+ self.assertEqual(r, loaded.ints)
+
+ def test_tuple(self):
+ instance = RangesModel(ints=(0, 10))
+ instance.save()
+ loaded = RangesModel.objects.get()
+ self.assertEqual(NumericRange(0, 10), loaded.ints)
+
+ def test_tuple_range_with_default_bounds(self):
+ range_ = (timezone.now(), timezone.now() + datetime.timedelta(hours=1))
+ RangesModel.objects.create(timestamps_closed_bounds=range_, timestamps=range_)
+ loaded = RangesModel.objects.get()
+ self.assertEqual(
+ loaded.timestamps_closed_bounds,
+ DateTimeTZRange(range_[0], range_[1], "[]"),
+ )
+ self.assertEqual(
+ loaded.timestamps,
+ DateTimeTZRange(range_[0], range_[1], "[)"),
+ )
+
+ def test_range_object_boundaries(self):
+ r = NumericRange(0, 10, "[]")
+ instance = RangesModel(decimals=r)
+ instance.save()
+ loaded = RangesModel.objects.get()
+ self.assertEqual(r, loaded.decimals)
+ self.assertIn(10, loaded.decimals)
+
+ def test_range_object_boundaries_range_with_default_bounds(self):
+ range_ = DateTimeTZRange(
+ timezone.now(),
+ timezone.now() + datetime.timedelta(hours=1),
+ bounds="()",
+ )
+ RangesModel.objects.create(timestamps_closed_bounds=range_)
+ loaded = RangesModel.objects.get()
+ self.assertEqual(loaded.timestamps_closed_bounds, range_)
+
+ def test_unbounded(self):
+ r = NumericRange(None, None, "()")
+ instance = RangesModel(decimals=r)
+ instance.save()
+ loaded = RangesModel.objects.get()
+ self.assertEqual(r, loaded.decimals)
+
+ def test_empty(self):
+ r = NumericRange(empty=True)
+ instance = RangesModel(ints=r)
+ instance.save()
+ loaded = RangesModel.objects.get()
+ self.assertEqual(r, loaded.ints)
+
+ def test_null(self):
+ instance = RangesModel(ints=None)
+ instance.save()
+ loaded = RangesModel.objects.get()
+ self.assertIsNone(loaded.ints)
+
+ def test_model_set_on_base_field(self):
+ instance = RangesModel()
+ field = instance._meta.get_field("ints")
+ self.assertEqual(field.model, RangesModel)
+ self.assertEqual(field.base_field.model, RangesModel)
+
+
+class TestRangeContainsLookup(PostgreSQLTestCase):
+ @classmethod
+ def setUpTestData(cls):
+ cls.timestamps = [
+ datetime.datetime(year=2016, month=1, day=1),
+ datetime.datetime(year=2016, month=1, day=2, hour=1),
+ datetime.datetime(year=2016, month=1, day=2, hour=12),
+ datetime.datetime(year=2016, month=1, day=3),
+ datetime.datetime(year=2016, month=1, day=3, hour=1),
+ datetime.datetime(year=2016, month=2, day=2),
+ ]
+ cls.aware_timestamps = [
+ timezone.make_aware(timestamp) for timestamp in cls.timestamps
+ ]
+ cls.dates = [
+ datetime.date(year=2016, month=1, day=1),
+ datetime.date(year=2016, month=1, day=2),
+ datetime.date(year=2016, month=1, day=3),
+ datetime.date(year=2016, month=1, day=4),
+ datetime.date(year=2016, month=2, day=2),
+ datetime.date(year=2016, month=2, day=3),
+ ]
+ cls.obj = RangesModel.objects.create(
+ dates=(cls.dates[0], cls.dates[3]),
+ dates_inner=(cls.dates[1], cls.dates[2]),
+ timestamps=(cls.timestamps[0], cls.timestamps[3]),
+ timestamps_inner=(cls.timestamps[1], cls.timestamps[2]),
+ )
+ cls.aware_obj = RangesModel.objects.create(
+ dates=(cls.dates[0], cls.dates[3]),
+ dates_inner=(cls.dates[1], cls.dates[2]),
+ timestamps=(cls.aware_timestamps[0], cls.aware_timestamps[3]),
+ timestamps_inner=(cls.timestamps[1], cls.timestamps[2]),
+ )
+ # Objects that don't match any queries.
+ for i in range(3, 4):
+ RangesModel.objects.create(
+ dates=(cls.dates[i], cls.dates[i + 1]),
+ timestamps=(cls.timestamps[i], cls.timestamps[i + 1]),
+ )
+ RangesModel.objects.create(
+ dates=(cls.dates[i], cls.dates[i + 1]),
+ timestamps=(cls.aware_timestamps[i], cls.aware_timestamps[i + 1]),
+ )
+
+ def test_datetime_range_contains(self):
+ filter_args = (
+ self.timestamps[1],
+ self.aware_timestamps[1],
+ (self.timestamps[1], self.timestamps[2]),
+ (self.aware_timestamps[1], self.aware_timestamps[2]),
+ Value(self.dates[0]),
+ Func(F("dates"), function="lower", output_field=DateTimeField()),
+ F("timestamps_inner"),
+ )
+ for filter_arg in filter_args:
+ with self.subTest(filter_arg=filter_arg):
+ self.assertCountEqual(
+ RangesModel.objects.filter(**{"timestamps__contains": filter_arg}),
+ [self.obj, self.aware_obj],
+ )
+
+ def test_date_range_contains(self):
+ filter_args = (
+ self.timestamps[1],
+ (self.dates[1], self.dates[2]),
+ Value(self.dates[0], output_field=DateField()),
+ Func(F("timestamps"), function="lower", output_field=DateField()),
+ F("dates_inner"),
+ )
+ for filter_arg in filter_args:
+ with self.subTest(filter_arg=filter_arg):
+ self.assertCountEqual(
+ RangesModel.objects.filter(**{"dates__contains": filter_arg}),
+ [self.obj, self.aware_obj],
+ )
+
+
+class TestQuerying(PostgreSQLTestCase):
+ @classmethod
+ def setUpTestData(cls):
+ cls.objs = RangesModel.objects.bulk_create(
+ [
+ RangesModel(ints=NumericRange(0, 10)),
+ RangesModel(ints=NumericRange(5, 15)),
+ RangesModel(ints=NumericRange(None, 0)),
+ RangesModel(ints=NumericRange(empty=True)),
+ RangesModel(ints=None),
+ ]
+ )
+
+ def test_exact(self):
+ self.assertSequenceEqual(
+ RangesModel.objects.filter(ints__exact=NumericRange(0, 10)),
+ [self.objs[0]],
+ )
+
+ def test_isnull(self):
+ self.assertSequenceEqual(
+ RangesModel.objects.filter(ints__isnull=True),
+ [self.objs[4]],
+ )
+
+ def test_isempty(self):
+ self.assertSequenceEqual(
+ RangesModel.objects.filter(ints__isempty=True),
+ [self.objs[3]],
+ )
+
+ def test_contains(self):
+ self.assertSequenceEqual(
+ RangesModel.objects.filter(ints__contains=8),
+ [self.objs[0], self.objs[1]],
+ )
+
+ def test_contains_range(self):
+ self.assertSequenceEqual(
+ RangesModel.objects.filter(ints__contains=NumericRange(3, 8)),
+ [self.objs[0]],
+ )
+
+ def test_contained_by(self):
+ self.assertSequenceEqual(
+ RangesModel.objects.filter(ints__contained_by=NumericRange(0, 20)),
+ [self.objs[0], self.objs[1], self.objs[3]],
+ )
+
+ def test_overlap(self):
+ self.assertSequenceEqual(
+ RangesModel.objects.filter(ints__overlap=NumericRange(3, 8)),
+ [self.objs[0], self.objs[1]],
+ )
+
+ def test_fully_lt(self):
+ self.assertSequenceEqual(
+ RangesModel.objects.filter(ints__fully_lt=NumericRange(5, 10)),
+ [self.objs[2]],
+ )
+
+ def test_fully_gt(self):
+ self.assertSequenceEqual(
+ RangesModel.objects.filter(ints__fully_gt=NumericRange(5, 10)),
+ [],
+ )
+
+ def test_not_lt(self):
+ self.assertSequenceEqual(
+ RangesModel.objects.filter(ints__not_lt=NumericRange(5, 10)),
+ [self.objs[1]],
+ )
+
+ def test_not_gt(self):
+ self.assertSequenceEqual(
+ RangesModel.objects.filter(ints__not_gt=NumericRange(5, 10)),
+ [self.objs[0], self.objs[2]],
+ )
+
+ def test_adjacent_to(self):
+ self.assertSequenceEqual(
+ RangesModel.objects.filter(ints__adjacent_to=NumericRange(0, 5)),
+ [self.objs[1], self.objs[2]],
+ )
+
+ def test_startswith(self):
+ self.assertSequenceEqual(
+ RangesModel.objects.filter(ints__startswith=0),
+ [self.objs[0]],
+ )
+
+ def test_endswith(self):
+ self.assertSequenceEqual(
+ RangesModel.objects.filter(ints__endswith=0),
+ [self.objs[2]],
+ )
+
+ def test_startswith_chaining(self):
+ self.assertSequenceEqual(
+ RangesModel.objects.filter(ints__startswith__gte=0),
+ [self.objs[0], self.objs[1]],
+ )
+
+ def test_bound_type(self):
+ decimals = RangesModel.objects.bulk_create(
+ [
+ RangesModel(decimals=NumericRange(None, 10)),
+ RangesModel(decimals=NumericRange(10, None)),
+ RangesModel(decimals=NumericRange(5, 15)),
+ RangesModel(decimals=NumericRange(5, 15, "(]")),
+ ]
+ )
+ tests = [
+ ("lower_inc", True, [decimals[1], decimals[2]]),
+ ("lower_inc", False, [decimals[0], decimals[3]]),
+ ("lower_inf", True, [decimals[0]]),
+ ("lower_inf", False, [decimals[1], decimals[2], decimals[3]]),
+ ("upper_inc", True, [decimals[3]]),
+ ("upper_inc", False, [decimals[0], decimals[1], decimals[2]]),
+ ("upper_inf", True, [decimals[1]]),
+ ("upper_inf", False, [decimals[0], decimals[2], decimals[3]]),
+ ]
+ for lookup, filter_arg, excepted_result in tests:
+ with self.subTest(lookup=lookup, filter_arg=filter_arg):
+ self.assertSequenceEqual(
+ RangesModel.objects.filter(**{"decimals__%s" % lookup: filter_arg}),
+ excepted_result,
+ )
+
+
+class TestQueryingWithRanges(PostgreSQLTestCase):
+ def test_date_range(self):
+ objs = [
+ RangeLookupsModel.objects.create(date="2015-01-01"),
+ RangeLookupsModel.objects.create(date="2015-05-05"),
+ ]
+ self.assertSequenceEqual(
+ RangeLookupsModel.objects.filter(
+ date__contained_by=DateRange("2015-01-01", "2015-05-04")
+ ),
+ [objs[0]],
+ )
+
+ def test_date_range_datetime_field(self):
+ objs = [
+ RangeLookupsModel.objects.create(timestamp="2015-01-01"),
+ RangeLookupsModel.objects.create(timestamp="2015-05-05"),
+ ]
+ self.assertSequenceEqual(
+ RangeLookupsModel.objects.filter(
+ timestamp__date__contained_by=DateRange("2015-01-01", "2015-05-04")
+ ),
+ [objs[0]],
+ )
+
+ def test_datetime_range(self):
+ objs = [
+ RangeLookupsModel.objects.create(timestamp="2015-01-01T09:00:00"),
+ RangeLookupsModel.objects.create(timestamp="2015-05-05T17:00:00"),
+ ]
+ self.assertSequenceEqual(
+ RangeLookupsModel.objects.filter(
+ timestamp__contained_by=DateTimeTZRange(
+ "2015-01-01T09:00", "2015-05-04T23:55"
+ )
+ ),
+ [objs[0]],
+ )
+
+ def test_small_integer_field_contained_by(self):
+ objs = [
+ RangeLookupsModel.objects.create(small_integer=8),
+ RangeLookupsModel.objects.create(small_integer=4),
+ RangeLookupsModel.objects.create(small_integer=-1),
+ ]
+ self.assertSequenceEqual(
+ RangeLookupsModel.objects.filter(
+ small_integer__contained_by=NumericRange(4, 6)
+ ),
+ [objs[1]],
+ )
+
+ def test_integer_range(self):
+ objs = [
+ RangeLookupsModel.objects.create(integer=5),
+ RangeLookupsModel.objects.create(integer=99),
+ RangeLookupsModel.objects.create(integer=-1),
+ ]
+ self.assertSequenceEqual(
+ RangeLookupsModel.objects.filter(integer__contained_by=NumericRange(1, 98)),
+ [objs[0]],
+ )
+
+ def test_biginteger_range(self):
+ objs = [
+ RangeLookupsModel.objects.create(big_integer=5),
+ RangeLookupsModel.objects.create(big_integer=99),
+ RangeLookupsModel.objects.create(big_integer=-1),
+ ]
+ self.assertSequenceEqual(
+ RangeLookupsModel.objects.filter(
+ big_integer__contained_by=NumericRange(1, 98)
+ ),
+ [objs[0]],
+ )
+
+ def test_decimal_field_contained_by(self):
+ objs = [
+ RangeLookupsModel.objects.create(decimal_field=Decimal("1.33")),
+ RangeLookupsModel.objects.create(decimal_field=Decimal("2.88")),
+ RangeLookupsModel.objects.create(decimal_field=Decimal("99.17")),
+ ]
+ self.assertSequenceEqual(
+ RangeLookupsModel.objects.filter(
+ decimal_field__contained_by=NumericRange(
+ Decimal("1.89"), Decimal("7.91")
+ ),
+ ),
+ [objs[1]],
+ )
+
+ def test_float_range(self):
+ objs = [
+ RangeLookupsModel.objects.create(float=5),
+ RangeLookupsModel.objects.create(float=99),
+ RangeLookupsModel.objects.create(float=-1),
+ ]
+ self.assertSequenceEqual(
+ RangeLookupsModel.objects.filter(float__contained_by=NumericRange(1, 98)),
+ [objs[0]],
+ )
+
+ def test_small_auto_field_contained_by(self):
+ objs = SmallAutoFieldModel.objects.bulk_create(
+ [SmallAutoFieldModel() for i in range(1, 5)]
+ )
+ self.assertSequenceEqual(
+ SmallAutoFieldModel.objects.filter(
+ id__contained_by=NumericRange(objs[1].pk, objs[3].pk),
+ ),
+ objs[1:3],
+ )
+
+ def test_auto_field_contained_by(self):
+ objs = RangeLookupsModel.objects.bulk_create(
+ [RangeLookupsModel() for i in range(1, 5)]
+ )
+ self.assertSequenceEqual(
+ RangeLookupsModel.objects.filter(
+ id__contained_by=NumericRange(objs[1].pk, objs[3].pk),
+ ),
+ objs[1:3],
+ )
+
+ def test_big_auto_field_contained_by(self):
+ objs = BigAutoFieldModel.objects.bulk_create(
+ [BigAutoFieldModel() for i in range(1, 5)]
+ )
+ self.assertSequenceEqual(
+ BigAutoFieldModel.objects.filter(
+ id__contained_by=NumericRange(objs[1].pk, objs[3].pk),
+ ),
+ objs[1:3],
+ )
+
+ def test_f_ranges(self):
+ parent = RangesModel.objects.create(decimals=NumericRange(0, 10))
+ objs = [
+ RangeLookupsModel.objects.create(float=5, parent=parent),
+ RangeLookupsModel.objects.create(float=99, parent=parent),
+ ]
+ self.assertSequenceEqual(
+ RangeLookupsModel.objects.filter(float__contained_by=F("parent__decimals")),
+ [objs[0]],
+ )
+
+ def test_exclude(self):
+ objs = [
+ RangeLookupsModel.objects.create(float=5),
+ RangeLookupsModel.objects.create(float=99),
+ RangeLookupsModel.objects.create(float=-1),
+ ]
+ self.assertSequenceEqual(
+ RangeLookupsModel.objects.exclude(float__contained_by=NumericRange(0, 100)),
+ [objs[2]],
+ )
+
+
+class TestSerialization(PostgreSQLSimpleTestCase):
+ test_data = (
+ '[{"fields": {"ints": "{\\"upper\\": \\"10\\", \\"lower\\": \\"0\\", '
+ '\\"bounds\\": \\"[)\\"}", "decimals": "{\\"empty\\": true}", '
+ '"bigints": null, "timestamps": '
+ '"{\\"upper\\": \\"2014-02-02T12:12:12+00:00\\", '
+ '\\"lower\\": \\"2014-01-01T00:00:00+00:00\\", \\"bounds\\": \\"[)\\"}", '
+ '"timestamps_inner": null, '
+ '"timestamps_closed_bounds": "{\\"upper\\": \\"2014-02-02T12:12:12+00:00\\", '
+ '\\"lower\\": \\"2014-01-01T00:00:00+00:00\\", \\"bounds\\": \\"()\\"}", '
+ '"dates": "{\\"upper\\": \\"2014-02-02\\", \\"lower\\": \\"2014-01-01\\", '
+ '\\"bounds\\": \\"[)\\"}", "dates_inner": null }, '
+ '"model": "postgres_tests.rangesmodel", "pk": null}]'
+ )
+
+ lower_date = datetime.date(2014, 1, 1)
+ upper_date = datetime.date(2014, 2, 2)
+ lower_dt = datetime.datetime(2014, 1, 1, 0, 0, 0, tzinfo=datetime.timezone.utc)
+ upper_dt = datetime.datetime(2014, 2, 2, 12, 12, 12, tzinfo=datetime.timezone.utc)
+
+ def test_dumping(self):
+ instance = RangesModel(
+ ints=NumericRange(0, 10),
+ decimals=NumericRange(empty=True),
+ timestamps=DateTimeTZRange(self.lower_dt, self.upper_dt),
+ timestamps_closed_bounds=DateTimeTZRange(
+ self.lower_dt,
+ self.upper_dt,
+ bounds="()",
+ ),
+ dates=DateRange(self.lower_date, self.upper_date),
+ )
+ data = serializers.serialize("json", [instance])
+ dumped = json.loads(data)
+ for field in ("ints", "dates", "timestamps", "timestamps_closed_bounds"):
+ dumped[0]["fields"][field] = json.loads(dumped[0]["fields"][field])
+ check = json.loads(self.test_data)
+ for field in ("ints", "dates", "timestamps", "timestamps_closed_bounds"):
+ check[0]["fields"][field] = json.loads(check[0]["fields"][field])
+
+ self.assertEqual(dumped, check)
+
+ def test_loading(self):
+ instance = list(serializers.deserialize("json", self.test_data))[0].object
+ self.assertEqual(instance.ints, NumericRange(0, 10))
+ self.assertEqual(instance.decimals, NumericRange(empty=True))
+ self.assertIsNone(instance.bigints)
+ self.assertEqual(instance.dates, DateRange(self.lower_date, self.upper_date))
+ self.assertEqual(
+ instance.timestamps, DateTimeTZRange(self.lower_dt, self.upper_dt)
+ )
+ self.assertEqual(
+ instance.timestamps_closed_bounds,
+ DateTimeTZRange(self.lower_dt, self.upper_dt, bounds="()"),
+ )
+
+ def test_serialize_range_with_null(self):
+ instance = RangesModel(ints=NumericRange(None, 10))
+ data = serializers.serialize("json", [instance])
+ new_instance = list(serializers.deserialize("json", data))[0].object
+ self.assertEqual(new_instance.ints, NumericRange(None, 10))
+
+ instance = RangesModel(ints=NumericRange(10, None))
+ data = serializers.serialize("json", [instance])
+ new_instance = list(serializers.deserialize("json", data))[0].object
+ self.assertEqual(new_instance.ints, NumericRange(10, None))
+
+
+class TestChecks(PostgreSQLSimpleTestCase):
+ def test_choices_tuple_list(self):
+ class Model(PostgreSQLModel):
+ field = pg_fields.IntegerRangeField(
+ choices=[
+ ["1-50", [((1, 25), "1-25"), ([26, 50], "26-50")]],
+ ((51, 100), "51-100"),
+ ],
+ )
+
+ self.assertEqual(Model._meta.get_field("field").check(), [])
+
+
+class TestValidators(PostgreSQLSimpleTestCase):
+ def test_max(self):
+ validator = RangeMaxValueValidator(5)
+ validator(NumericRange(0, 5))
+ msg = "Ensure that the upper bound of the range is not greater than 5."
+ with self.assertRaises(exceptions.ValidationError) as cm:
+ validator(NumericRange(0, 10))
+ self.assertEqual(cm.exception.messages[0], msg)
+ self.assertEqual(cm.exception.code, "max_value")
+ with self.assertRaisesMessage(exceptions.ValidationError, msg):
+ validator(NumericRange(0, None)) # an unbound range
+
+ def test_min(self):
+ validator = RangeMinValueValidator(5)
+ validator(NumericRange(10, 15))
+ msg = "Ensure that the lower bound of the range is not less than 5."
+ with self.assertRaises(exceptions.ValidationError) as cm:
+ validator(NumericRange(0, 10))
+ self.assertEqual(cm.exception.messages[0], msg)
+ self.assertEqual(cm.exception.code, "min_value")
+ with self.assertRaisesMessage(exceptions.ValidationError, msg):
+ validator(NumericRange(None, 10)) # an unbound range
+
+
+class TestFormField(PostgreSQLSimpleTestCase):
+ def test_valid_integer(self):
+ field = pg_forms.IntegerRangeField()
+ value = field.clean(["1", "2"])
+ self.assertEqual(value, NumericRange(1, 2))
+
+ def test_valid_decimal(self):
+ field = pg_forms.DecimalRangeField()
+ value = field.clean(["1.12345", "2.001"])
+ self.assertEqual(value, NumericRange(Decimal("1.12345"), Decimal("2.001")))
+
+ def test_valid_timestamps(self):
+ field = pg_forms.DateTimeRangeField()
+ value = field.clean(["01/01/2014 00:00:00", "02/02/2014 12:12:12"])
+ lower = datetime.datetime(2014, 1, 1, 0, 0, 0)
+ upper = datetime.datetime(2014, 2, 2, 12, 12, 12)
+ self.assertEqual(value, DateTimeTZRange(lower, upper))
+
+ def test_valid_dates(self):
+ field = pg_forms.DateRangeField()
+ value = field.clean(["01/01/2014", "02/02/2014"])
+ lower = datetime.date(2014, 1, 1)
+ upper = datetime.date(2014, 2, 2)
+ self.assertEqual(value, DateRange(lower, upper))
+
+ def test_using_split_datetime_widget(self):
+ class SplitDateTimeRangeField(pg_forms.DateTimeRangeField):
+ base_field = forms.SplitDateTimeField
+
+ class SplitForm(forms.Form):
+ field = SplitDateTimeRangeField()
+
+ form = SplitForm()
+ self.assertHTMLEqual(
+ str(form),
+ """
+
+
+
+ """,
+ )
+ form = SplitForm(
+ {
+ "field_0_0": "01/01/2014",
+ "field_0_1": "00:00:00",
+ "field_1_0": "02/02/2014",
+ "field_1_1": "12:12:12",
+ }
+ )
+ self.assertTrue(form.is_valid())
+ lower = datetime.datetime(2014, 1, 1, 0, 0, 0)
+ upper = datetime.datetime(2014, 2, 2, 12, 12, 12)
+ self.assertEqual(form.cleaned_data["field"], DateTimeTZRange(lower, upper))
+
+ def test_none(self):
+ field = pg_forms.IntegerRangeField(required=False)
+ value = field.clean(["", ""])
+ self.assertIsNone(value)
+
+ def test_datetime_form_as_table(self):
+ class DateTimeRangeForm(forms.Form):
+ datetime_field = pg_forms.DateTimeRangeField(show_hidden_initial=True)
+
+ form = DateTimeRangeForm()
+ self.assertHTMLEqual(
+ form.as_table(),
+ """
+ |
+
+ |
+
+
+
+
+ |
|---|
+ """,
+ )
+ form = DateTimeRangeForm(
+ {
+ "datetime_field_0": "2010-01-01 11:13:00",
+ "datetime_field_1": "2020-12-12 16:59:00",
+ }
+ )
+ self.assertHTMLEqual(
+ form.as_table(),
+ """
+ |
+
+ |
+
+
+
+ |
|---|
+ """,
+ )
+
+ def test_datetime_form_initial_data(self):
+ class DateTimeRangeForm(forms.Form):
+ datetime_field = pg_forms.DateTimeRangeField(show_hidden_initial=True)
+
+ data = QueryDict(mutable=True)
+ data.update(
+ {
+ "datetime_field_0": "2010-01-01 11:13:00",
+ "datetime_field_1": "",
+ "initial-datetime_field_0": "2010-01-01 10:12:00",
+ "initial-datetime_field_1": "",
+ }
+ )
+ form = DateTimeRangeForm(data=data)
+ self.assertTrue(form.has_changed())
+
+ data["initial-datetime_field_0"] = "2010-01-01 11:13:00"
+ form = DateTimeRangeForm(data=data)
+ self.assertFalse(form.has_changed())
+
+ def test_rendering(self):
+ class RangeForm(forms.Form):
+ ints = pg_forms.IntegerRangeField()
+
+ self.assertHTMLEqual(
+ str(RangeForm()),
+ """
+
+
+
+ """,
+ )
+
+ def test_integer_lower_bound_higher(self):
+ field = pg_forms.IntegerRangeField()
+ with self.assertRaises(exceptions.ValidationError) as cm:
+ field.clean(["10", "2"])
+ self.assertEqual(
+ cm.exception.messages[0],
+ "The start of the range must not exceed the end of the range.",
+ )
+ self.assertEqual(cm.exception.code, "bound_ordering")
+
+ def test_integer_open(self):
+ field = pg_forms.IntegerRangeField()
+ value = field.clean(["", "0"])
+ self.assertEqual(value, NumericRange(None, 0))
+
+ def test_integer_incorrect_data_type(self):
+ field = pg_forms.IntegerRangeField()
+ with self.assertRaises(exceptions.ValidationError) as cm:
+ field.clean("1")
+ self.assertEqual(cm.exception.messages[0], "Enter two whole numbers.")
+ self.assertEqual(cm.exception.code, "invalid")
+
+ def test_integer_invalid_lower(self):
+ field = pg_forms.IntegerRangeField()
+ with self.assertRaises(exceptions.ValidationError) as cm:
+ field.clean(["a", "2"])
+ self.assertEqual(cm.exception.messages[0], "Enter a whole number.")
+
+ def test_integer_invalid_upper(self):
+ field = pg_forms.IntegerRangeField()
+ with self.assertRaises(exceptions.ValidationError) as cm:
+ field.clean(["1", "b"])
+ self.assertEqual(cm.exception.messages[0], "Enter a whole number.")
+
+ def test_integer_required(self):
+ field = pg_forms.IntegerRangeField(required=True)
+ with self.assertRaises(exceptions.ValidationError) as cm:
+ field.clean(["", ""])
+ self.assertEqual(cm.exception.messages[0], "This field is required.")
+ value = field.clean([1, ""])
+ self.assertEqual(value, NumericRange(1, None))
+
+ def test_decimal_lower_bound_higher(self):
+ field = pg_forms.DecimalRangeField()
+ with self.assertRaises(exceptions.ValidationError) as cm:
+ field.clean(["1.8", "1.6"])
+ self.assertEqual(
+ cm.exception.messages[0],
+ "The start of the range must not exceed the end of the range.",
+ )
+ self.assertEqual(cm.exception.code, "bound_ordering")
+
+ def test_decimal_open(self):
+ field = pg_forms.DecimalRangeField()
+ value = field.clean(["", "3.1415926"])
+ self.assertEqual(value, NumericRange(None, Decimal("3.1415926")))
+
+ def test_decimal_incorrect_data_type(self):
+ field = pg_forms.DecimalRangeField()
+ with self.assertRaises(exceptions.ValidationError) as cm:
+ field.clean("1.6")
+ self.assertEqual(cm.exception.messages[0], "Enter two numbers.")
+ self.assertEqual(cm.exception.code, "invalid")
+
+ def test_decimal_invalid_lower(self):
+ field = pg_forms.DecimalRangeField()
+ with self.assertRaises(exceptions.ValidationError) as cm:
+ field.clean(["a", "3.1415926"])
+ self.assertEqual(cm.exception.messages[0], "Enter a number.")
+
+ def test_decimal_invalid_upper(self):
+ field = pg_forms.DecimalRangeField()
+ with self.assertRaises(exceptions.ValidationError) as cm:
+ field.clean(["1.61803399", "b"])
+ self.assertEqual(cm.exception.messages[0], "Enter a number.")
+
+ def test_decimal_required(self):
+ field = pg_forms.DecimalRangeField(required=True)
+ with self.assertRaises(exceptions.ValidationError) as cm:
+ field.clean(["", ""])
+ self.assertEqual(cm.exception.messages[0], "This field is required.")
+ value = field.clean(["1.61803399", ""])
+ self.assertEqual(value, NumericRange(Decimal("1.61803399"), None))
+
+ def test_date_lower_bound_higher(self):
+ field = pg_forms.DateRangeField()
+ with self.assertRaises(exceptions.ValidationError) as cm:
+ field.clean(["2013-04-09", "1976-04-16"])
+ self.assertEqual(
+ cm.exception.messages[0],
+ "The start of the range must not exceed the end of the range.",
+ )
+ self.assertEqual(cm.exception.code, "bound_ordering")
+
+ def test_date_open(self):
+ field = pg_forms.DateRangeField()
+ value = field.clean(["", "2013-04-09"])
+ self.assertEqual(value, DateRange(None, datetime.date(2013, 4, 9)))
+
+ def test_date_incorrect_data_type(self):
+ field = pg_forms.DateRangeField()
+ with self.assertRaises(exceptions.ValidationError) as cm:
+ field.clean("1")
+ self.assertEqual(cm.exception.messages[0], "Enter two valid dates.")
+ self.assertEqual(cm.exception.code, "invalid")
+
+ def test_date_invalid_lower(self):
+ field = pg_forms.DateRangeField()
+ with self.assertRaises(exceptions.ValidationError) as cm:
+ field.clean(["a", "2013-04-09"])
+ self.assertEqual(cm.exception.messages[0], "Enter a valid date.")
+
+ def test_date_invalid_upper(self):
+ field = pg_forms.DateRangeField()
+ with self.assertRaises(exceptions.ValidationError) as cm:
+ field.clean(["2013-04-09", "b"])
+ self.assertEqual(cm.exception.messages[0], "Enter a valid date.")
+
+ def test_date_required(self):
+ field = pg_forms.DateRangeField(required=True)
+ with self.assertRaises(exceptions.ValidationError) as cm:
+ field.clean(["", ""])
+ self.assertEqual(cm.exception.messages[0], "This field is required.")
+ value = field.clean(["1976-04-16", ""])
+ self.assertEqual(value, DateRange(datetime.date(1976, 4, 16), None))
+
+ def test_date_has_changed_first(self):
+ self.assertTrue(
+ pg_forms.DateRangeField().has_changed(
+ ["2010-01-01", "2020-12-12"],
+ ["2010-01-31", "2020-12-12"],
+ )
+ )
+
+ def test_date_has_changed_last(self):
+ self.assertTrue(
+ pg_forms.DateRangeField().has_changed(
+ ["2010-01-01", "2020-12-12"],
+ ["2010-01-01", "2020-12-31"],
+ )
+ )
+
+ def test_datetime_lower_bound_higher(self):
+ field = pg_forms.DateTimeRangeField()
+ with self.assertRaises(exceptions.ValidationError) as cm:
+ field.clean(["2006-10-25 14:59", "2006-10-25 14:58"])
+ self.assertEqual(
+ cm.exception.messages[0],
+ "The start of the range must not exceed the end of the range.",
+ )
+ self.assertEqual(cm.exception.code, "bound_ordering")
+
+ def test_datetime_open(self):
+ field = pg_forms.DateTimeRangeField()
+ value = field.clean(["", "2013-04-09 11:45"])
+ self.assertEqual(
+ value, DateTimeTZRange(None, datetime.datetime(2013, 4, 9, 11, 45))
+ )
+
+ def test_datetime_incorrect_data_type(self):
+ field = pg_forms.DateTimeRangeField()
+ with self.assertRaises(exceptions.ValidationError) as cm:
+ field.clean("2013-04-09 11:45")
+ self.assertEqual(cm.exception.messages[0], "Enter two valid date/times.")
+ self.assertEqual(cm.exception.code, "invalid")
+
+ def test_datetime_invalid_lower(self):
+ field = pg_forms.DateTimeRangeField()
+ with self.assertRaises(exceptions.ValidationError) as cm:
+ field.clean(["45", "2013-04-09 11:45"])
+ self.assertEqual(cm.exception.messages[0], "Enter a valid date/time.")
+
+ def test_datetime_invalid_upper(self):
+ field = pg_forms.DateTimeRangeField()
+ with self.assertRaises(exceptions.ValidationError) as cm:
+ field.clean(["2013-04-09 11:45", "sweet pickles"])
+ self.assertEqual(cm.exception.messages[0], "Enter a valid date/time.")
+
+ def test_datetime_required(self):
+ field = pg_forms.DateTimeRangeField(required=True)
+ with self.assertRaises(exceptions.ValidationError) as cm:
+ field.clean(["", ""])
+ self.assertEqual(cm.exception.messages[0], "This field is required.")
+ value = field.clean(["2013-04-09 11:45", ""])
+ self.assertEqual(
+ value, DateTimeTZRange(datetime.datetime(2013, 4, 9, 11, 45), None)
+ )
+
+ @override_settings(USE_TZ=True, TIME_ZONE="Africa/Johannesburg")
+ def test_datetime_prepare_value(self):
+ field = pg_forms.DateTimeRangeField()
+ value = field.prepare_value(
+ DateTimeTZRange(
+ datetime.datetime(2015, 5, 22, 16, 6, 33, tzinfo=datetime.timezone.utc),
+ None,
+ )
+ )
+ self.assertEqual(value, [datetime.datetime(2015, 5, 22, 18, 6, 33), None])
+
+ def test_datetime_has_changed_first(self):
+ self.assertTrue(
+ pg_forms.DateTimeRangeField().has_changed(
+ ["2010-01-01 00:00", "2020-12-12 00:00"],
+ ["2010-01-31 23:00", "2020-12-12 00:00"],
+ )
+ )
+
+ def test_datetime_has_changed_last(self):
+ self.assertTrue(
+ pg_forms.DateTimeRangeField().has_changed(
+ ["2010-01-01 00:00", "2020-12-12 00:00"],
+ ["2010-01-01 00:00", "2020-12-31 23:00"],
+ )
+ )
+
+ def test_model_field_formfield_integer(self):
+ model_field = pg_fields.IntegerRangeField()
+ form_field = model_field.formfield()
+ self.assertIsInstance(form_field, pg_forms.IntegerRangeField)
+ self.assertEqual(form_field.range_kwargs, {})
+
+ def test_model_field_formfield_biginteger(self):
+ model_field = pg_fields.BigIntegerRangeField()
+ form_field = model_field.formfield()
+ self.assertIsInstance(form_field, pg_forms.IntegerRangeField)
+ self.assertEqual(form_field.range_kwargs, {})
+
+ def test_model_field_formfield_float(self):
+ model_field = pg_fields.DecimalRangeField(default_bounds="()")
+ form_field = model_field.formfield()
+ self.assertIsInstance(form_field, pg_forms.DecimalRangeField)
+ self.assertEqual(form_field.range_kwargs, {"bounds": "()"})
+
+ def test_model_field_formfield_date(self):
+ model_field = pg_fields.DateRangeField()
+ form_field = model_field.formfield()
+ self.assertIsInstance(form_field, pg_forms.DateRangeField)
+ self.assertEqual(form_field.range_kwargs, {})
+
+ def test_model_field_formfield_datetime(self):
+ model_field = pg_fields.DateTimeRangeField()
+ form_field = model_field.formfield()
+ self.assertIsInstance(form_field, pg_forms.DateTimeRangeField)
+ self.assertEqual(
+ form_field.range_kwargs,
+ {"bounds": pg_fields.ranges.CANONICAL_RANGE_BOUNDS},
+ )
+
+ def test_model_field_formfield_datetime_default_bounds(self):
+ model_field = pg_fields.DateTimeRangeField(default_bounds="[]")
+ form_field = model_field.formfield()
+ self.assertIsInstance(form_field, pg_forms.DateTimeRangeField)
+ self.assertEqual(form_field.range_kwargs, {"bounds": "[]"})
+
+ def test_model_field_with_default_bounds(self):
+ field = pg_forms.DateTimeRangeField(default_bounds="[]")
+ value = field.clean(["2014-01-01 00:00:00", "2014-02-03 12:13:14"])
+ lower = datetime.datetime(2014, 1, 1, 0, 0, 0)
+ upper = datetime.datetime(2014, 2, 3, 12, 13, 14)
+ self.assertEqual(value, DateTimeTZRange(lower, upper, "[]"))
+
+ def test_has_changed(self):
+ for field, value in (
+ (pg_forms.DateRangeField(), ["2010-01-01", "2020-12-12"]),
+ (pg_forms.DateTimeRangeField(), ["2010-01-01 11:13", "2020-12-12 14:52"]),
+ (pg_forms.IntegerRangeField(), [1, 2]),
+ (pg_forms.DecimalRangeField(), ["1.12345", "2.001"]),
+ ):
+ with self.subTest(field=field.__class__.__name__):
+ self.assertTrue(field.has_changed(None, value))
+ self.assertTrue(field.has_changed([value[0], ""], value))
+ self.assertTrue(field.has_changed(["", value[1]], value))
+ self.assertFalse(field.has_changed(value, value))
+
+
+class TestWidget(PostgreSQLSimpleTestCase):
+ def test_range_widget(self):
+ f = pg_forms.ranges.DateTimeRangeField()
+ self.assertHTMLEqual(
+ f.widget.render("datetimerange", ""),
+ ''
+ '',
+ )
+ self.assertHTMLEqual(
+ f.widget.render("datetimerange", None),
+ ''
+ '',
+ )
+ dt_range = DateTimeTZRange(
+ datetime.datetime(2006, 1, 10, 7, 30), datetime.datetime(2006, 2, 12, 9, 50)
+ )
+ self.assertHTMLEqual(
+ f.widget.render("datetimerange", dt_range),
+ ''
+ '',
+ )
+
+ def test_range_widget_render_tuple_value(self):
+ field = pg_forms.ranges.DateTimeRangeField()
+ dt_range_tuple = (
+ datetime.datetime(2022, 4, 22, 10, 24),
+ datetime.datetime(2022, 5, 12, 9, 25),
+ )
+ self.assertHTMLEqual(
+ field.widget.render("datetimerange", dt_range_tuple),
+ ''
+ '',
+ )
diff --git a/testbed/django__django/tests/postgres_tests/test_search.py b/testbed/django__django/tests/postgres_tests/test_search.py
new file mode 100644
index 0000000000000000000000000000000000000000..6f6318899c2712c6222ab8533bb155df2c1a646d
--- /dev/null
+++ b/testbed/django__django/tests/postgres_tests/test_search.py
@@ -0,0 +1,770 @@
+"""
+Test PostgreSQL full text search.
+
+These tests use dialogue from the 1975 film Monty Python and the Holy Grail.
+All text copyright Python (Monty) Pictures. Thanks to sacred-texts.com for the
+transcript.
+"""
+from django.db.models import F, Value
+
+from . import PostgreSQLSimpleTestCase, PostgreSQLTestCase
+from .models import Character, Line, LineSavedSearch, Scene
+
+try:
+ from django.contrib.postgres.search import (
+ SearchConfig,
+ SearchHeadline,
+ SearchQuery,
+ SearchRank,
+ SearchVector,
+ )
+except ImportError:
+ pass
+
+
+class GrailTestData:
+ @classmethod
+ def setUpTestData(cls):
+ cls.robin = Scene.objects.create(
+ scene="Scene 10", setting="The dark forest of Ewing"
+ )
+ cls.minstrel = Character.objects.create(name="Minstrel")
+ verses = [
+ (
+ "Bravely bold Sir Robin, rode forth from Camelot. "
+ "He was not afraid to die, o Brave Sir Robin. "
+ "He was not at all afraid to be killed in nasty ways. "
+ "Brave, brave, brave, brave Sir Robin"
+ ),
+ (
+ "He was not in the least bit scared to be mashed into a pulp, "
+ "Or to have his eyes gouged out, and his elbows broken. "
+ "To have his kneecaps split, and his body burned away, "
+ "And his limbs all hacked and mangled, brave Sir Robin!"
+ ),
+ (
+ "His head smashed in and his heart cut out, "
+ "And his liver removed and his bowels unplugged, "
+ "And his nostrils ripped and his bottom burned off,"
+ "And his --"
+ ),
+ ]
+ cls.verses = [
+ Line.objects.create(
+ scene=cls.robin,
+ character=cls.minstrel,
+ dialogue=verse,
+ )
+ for verse in verses
+ ]
+ cls.verse0, cls.verse1, cls.verse2 = cls.verses
+
+ cls.witch_scene = Scene.objects.create(
+ scene="Scene 5", setting="Sir Bedemir's Castle"
+ )
+ bedemir = Character.objects.create(name="Bedemir")
+ crowd = Character.objects.create(name="Crowd")
+ witch = Character.objects.create(name="Witch")
+ duck = Character.objects.create(name="Duck")
+
+ cls.bedemir0 = Line.objects.create(
+ scene=cls.witch_scene,
+ character=bedemir,
+ dialogue="We shall use my larger scales!",
+ dialogue_config="english",
+ )
+ cls.bedemir1 = Line.objects.create(
+ scene=cls.witch_scene,
+ character=bedemir,
+ dialogue="Right, remove the supports!",
+ dialogue_config="english",
+ )
+ cls.duck = Line.objects.create(
+ scene=cls.witch_scene, character=duck, dialogue=None
+ )
+ cls.crowd = Line.objects.create(
+ scene=cls.witch_scene, character=crowd, dialogue="A witch! A witch!"
+ )
+ cls.witch = Line.objects.create(
+ scene=cls.witch_scene, character=witch, dialogue="It's a fair cop."
+ )
+
+ trojan_rabbit = Scene.objects.create(
+ scene="Scene 8", setting="The castle of Our Master Ruiz' de lu la Ramper"
+ )
+ guards = Character.objects.create(name="French Guards")
+ cls.french = Line.objects.create(
+ scene=trojan_rabbit,
+ character=guards,
+ dialogue="Oh. Un beau cadeau. Oui oui.",
+ dialogue_config="french",
+ )
+
+
+class SimpleSearchTest(GrailTestData, PostgreSQLTestCase):
+ def test_simple(self):
+ searched = Line.objects.filter(dialogue__search="elbows")
+ self.assertSequenceEqual(searched, [self.verse1])
+
+ def test_non_exact_match(self):
+ self.check_default_text_search_config()
+ searched = Line.objects.filter(dialogue__search="hearts")
+ self.assertSequenceEqual(searched, [self.verse2])
+
+ def test_search_two_terms(self):
+ self.check_default_text_search_config()
+ searched = Line.objects.filter(dialogue__search="heart bowel")
+ self.assertSequenceEqual(searched, [self.verse2])
+
+ def test_search_two_terms_with_partial_match(self):
+ searched = Line.objects.filter(dialogue__search="Robin killed")
+ self.assertSequenceEqual(searched, [self.verse0])
+
+ def test_search_query_config(self):
+ searched = Line.objects.filter(
+ dialogue__search=SearchQuery("nostrils", config="simple"),
+ )
+ self.assertSequenceEqual(searched, [self.verse2])
+
+ def test_search_with_F_expression(self):
+ # Non-matching query.
+ LineSavedSearch.objects.create(line=self.verse1, query="hearts")
+ # Matching query.
+ match = LineSavedSearch.objects.create(line=self.verse1, query="elbows")
+ for query_expression in [F("query"), SearchQuery(F("query"))]:
+ with self.subTest(query_expression):
+ searched = LineSavedSearch.objects.filter(
+ line__dialogue__search=query_expression,
+ )
+ self.assertSequenceEqual(searched, [match])
+
+
+class SearchVectorFieldTest(GrailTestData, PostgreSQLTestCase):
+ def test_existing_vector(self):
+ Line.objects.update(dialogue_search_vector=SearchVector("dialogue"))
+ searched = Line.objects.filter(
+ dialogue_search_vector=SearchQuery("Robin killed")
+ )
+ self.assertSequenceEqual(searched, [self.verse0])
+
+ def test_existing_vector_config_explicit(self):
+ Line.objects.update(dialogue_search_vector=SearchVector("dialogue"))
+ searched = Line.objects.filter(
+ dialogue_search_vector=SearchQuery("cadeaux", config="french")
+ )
+ self.assertSequenceEqual(searched, [self.french])
+
+ def test_single_coalesce_expression(self):
+ searched = Line.objects.annotate(search=SearchVector("dialogue")).filter(
+ search="cadeaux"
+ )
+ self.assertNotIn("COALESCE(COALESCE", str(searched.query))
+
+ def test_values_with_percent(self):
+ searched = Line.objects.annotate(
+ search=SearchVector(Value("This week everything is 10% off"))
+ ).filter(search="10 % off")
+ self.assertEqual(len(searched), 9)
+
+
+class SearchConfigTests(PostgreSQLSimpleTestCase):
+ def test_from_parameter(self):
+ self.assertIsNone(SearchConfig.from_parameter(None))
+ self.assertEqual(SearchConfig.from_parameter("foo"), SearchConfig("foo"))
+ self.assertEqual(
+ SearchConfig.from_parameter(SearchConfig("bar")), SearchConfig("bar")
+ )
+
+
+class MultipleFieldsTest(GrailTestData, PostgreSQLTestCase):
+ def test_simple_on_dialogue(self):
+ searched = Line.objects.annotate(
+ search=SearchVector("scene__setting", "dialogue"),
+ ).filter(search="elbows")
+ self.assertSequenceEqual(searched, [self.verse1])
+
+ def test_simple_on_scene(self):
+ searched = Line.objects.annotate(
+ search=SearchVector("scene__setting", "dialogue"),
+ ).filter(search="Forest")
+ self.assertCountEqual(searched, self.verses)
+
+ def test_non_exact_match(self):
+ searched = Line.objects.annotate(
+ search=SearchVector("scene__setting", "dialogue"),
+ ).filter(search="heart")
+ self.assertSequenceEqual(searched, [self.verse2])
+
+ def test_search_two_terms(self):
+ searched = Line.objects.annotate(
+ search=SearchVector("scene__setting", "dialogue"),
+ ).filter(search="heart forest")
+ self.assertSequenceEqual(searched, [self.verse2])
+
+ def test_terms_adjacent(self):
+ searched = Line.objects.annotate(
+ search=SearchVector("character__name", "dialogue"),
+ ).filter(search="minstrel")
+ self.assertCountEqual(searched, self.verses)
+ searched = Line.objects.annotate(
+ search=SearchVector("scene__setting", "dialogue"),
+ ).filter(search="minstrelbravely")
+ self.assertSequenceEqual(searched, [])
+
+ def test_search_with_null(self):
+ searched = Line.objects.annotate(
+ search=SearchVector("scene__setting", "dialogue"),
+ ).filter(search="bedemir")
+ self.assertCountEqual(
+ searched, [self.bedemir0, self.bedemir1, self.crowd, self.witch, self.duck]
+ )
+
+ def test_search_with_non_text(self):
+ searched = Line.objects.annotate(
+ search=SearchVector("id"),
+ ).filter(search=str(self.crowd.id))
+ self.assertSequenceEqual(searched, [self.crowd])
+
+ def test_phrase_search(self):
+ line_qs = Line.objects.annotate(search=SearchVector("dialogue"))
+ searched = line_qs.filter(
+ search=SearchQuery("burned body his away", search_type="phrase")
+ )
+ self.assertSequenceEqual(searched, [])
+ searched = line_qs.filter(
+ search=SearchQuery("his body burned away", search_type="phrase")
+ )
+ self.assertSequenceEqual(searched, [self.verse1])
+
+ def test_phrase_search_with_config(self):
+ line_qs = Line.objects.annotate(
+ search=SearchVector("scene__setting", "dialogue", config="french"),
+ )
+ searched = line_qs.filter(
+ search=SearchQuery("cadeau beau un", search_type="phrase", config="french"),
+ )
+ self.assertSequenceEqual(searched, [])
+ searched = line_qs.filter(
+ search=SearchQuery("un beau cadeau", search_type="phrase", config="french"),
+ )
+ self.assertSequenceEqual(searched, [self.french])
+
+ def test_raw_search(self):
+ line_qs = Line.objects.annotate(search=SearchVector("dialogue"))
+ searched = line_qs.filter(search=SearchQuery("Robin", search_type="raw"))
+ self.assertCountEqual(searched, [self.verse0, self.verse1])
+ searched = line_qs.filter(
+ search=SearchQuery("Robin & !'Camelot'", search_type="raw")
+ )
+ self.assertSequenceEqual(searched, [self.verse1])
+
+ def test_raw_search_with_config(self):
+ line_qs = Line.objects.annotate(
+ search=SearchVector("dialogue", config="french")
+ )
+ searched = line_qs.filter(
+ search=SearchQuery(
+ "'cadeaux' & 'beaux'", search_type="raw", config="french"
+ ),
+ )
+ self.assertSequenceEqual(searched, [self.french])
+
+ def test_web_search(self):
+ line_qs = Line.objects.annotate(search=SearchVector("dialogue"))
+ searched = line_qs.filter(
+ search=SearchQuery(
+ '"burned body" "split kneecaps"',
+ search_type="websearch",
+ ),
+ )
+ self.assertSequenceEqual(searched, [])
+ searched = line_qs.filter(
+ search=SearchQuery(
+ '"body burned" "kneecaps split" -"nostrils"',
+ search_type="websearch",
+ ),
+ )
+ self.assertSequenceEqual(searched, [self.verse1])
+ searched = line_qs.filter(
+ search=SearchQuery(
+ '"Sir Robin" ("kneecaps" OR "Camelot")',
+ search_type="websearch",
+ ),
+ )
+ self.assertSequenceEqual(searched, [self.verse0, self.verse1])
+
+ def test_web_search_with_config(self):
+ line_qs = Line.objects.annotate(
+ search=SearchVector("scene__setting", "dialogue", config="french"),
+ )
+ searched = line_qs.filter(
+ search=SearchQuery(
+ "cadeau -beau", search_type="websearch", config="french"
+ ),
+ )
+ self.assertSequenceEqual(searched, [])
+ searched = line_qs.filter(
+ search=SearchQuery("beau cadeau", search_type="websearch", config="french"),
+ )
+ self.assertSequenceEqual(searched, [self.french])
+
+ def test_bad_search_type(self):
+ with self.assertRaisesMessage(
+ ValueError, "Unknown search_type argument 'foo'."
+ ):
+ SearchQuery("kneecaps", search_type="foo")
+
+ def test_config_query_explicit(self):
+ searched = Line.objects.annotate(
+ search=SearchVector("scene__setting", "dialogue", config="french"),
+ ).filter(search=SearchQuery("cadeaux", config="french"))
+ self.assertSequenceEqual(searched, [self.french])
+
+ def test_config_query_implicit(self):
+ searched = Line.objects.annotate(
+ search=SearchVector("scene__setting", "dialogue", config="french"),
+ ).filter(search="cadeaux")
+ self.assertSequenceEqual(searched, [self.french])
+
+ def test_config_from_field_explicit(self):
+ searched = Line.objects.annotate(
+ search=SearchVector(
+ "scene__setting", "dialogue", config=F("dialogue_config")
+ ),
+ ).filter(search=SearchQuery("cadeaux", config=F("dialogue_config")))
+ self.assertSequenceEqual(searched, [self.french])
+
+ def test_config_from_field_implicit(self):
+ searched = Line.objects.annotate(
+ search=SearchVector(
+ "scene__setting", "dialogue", config=F("dialogue_config")
+ ),
+ ).filter(search="cadeaux")
+ self.assertSequenceEqual(searched, [self.french])
+
+
+class TestCombinations(GrailTestData, PostgreSQLTestCase):
+ def test_vector_add(self):
+ searched = Line.objects.annotate(
+ search=SearchVector("scene__setting") + SearchVector("character__name"),
+ ).filter(search="bedemir")
+ self.assertCountEqual(
+ searched, [self.bedemir0, self.bedemir1, self.crowd, self.witch, self.duck]
+ )
+
+ def test_vector_add_multi(self):
+ searched = Line.objects.annotate(
+ search=(
+ SearchVector("scene__setting")
+ + SearchVector("character__name")
+ + SearchVector("dialogue")
+ ),
+ ).filter(search="bedemir")
+ self.assertCountEqual(
+ searched, [self.bedemir0, self.bedemir1, self.crowd, self.witch, self.duck]
+ )
+
+ def test_vector_combined_mismatch(self):
+ msg = (
+ "SearchVector can only be combined with other SearchVector "
+ "instances, got NoneType."
+ )
+ with self.assertRaisesMessage(TypeError, msg):
+ Line.objects.filter(dialogue__search=None + SearchVector("character__name"))
+
+ def test_combine_different_vector_configs(self):
+ self.check_default_text_search_config()
+ searched = Line.objects.annotate(
+ search=(
+ SearchVector("dialogue", config="english")
+ + SearchVector("dialogue", config="french")
+ ),
+ ).filter(
+ search=SearchQuery("cadeaux", config="french") | SearchQuery("nostrils")
+ )
+ self.assertCountEqual(searched, [self.french, self.verse2])
+
+ def test_query_and(self):
+ searched = Line.objects.annotate(
+ search=SearchVector("scene__setting", "dialogue"),
+ ).filter(search=SearchQuery("bedemir") & SearchQuery("scales"))
+ self.assertSequenceEqual(searched, [self.bedemir0])
+
+ def test_query_multiple_and(self):
+ searched = Line.objects.annotate(
+ search=SearchVector("scene__setting", "dialogue"),
+ ).filter(
+ search=SearchQuery("bedemir")
+ & SearchQuery("scales")
+ & SearchQuery("nostrils")
+ )
+ self.assertSequenceEqual(searched, [])
+
+ searched = Line.objects.annotate(
+ search=SearchVector("scene__setting", "dialogue"),
+ ).filter(
+ search=SearchQuery("shall") & SearchQuery("use") & SearchQuery("larger")
+ )
+ self.assertSequenceEqual(searched, [self.bedemir0])
+
+ def test_query_or(self):
+ searched = Line.objects.filter(
+ dialogue__search=SearchQuery("kneecaps") | SearchQuery("nostrils")
+ )
+ self.assertCountEqual(searched, [self.verse1, self.verse2])
+
+ def test_query_multiple_or(self):
+ searched = Line.objects.filter(
+ dialogue__search=SearchQuery("kneecaps")
+ | SearchQuery("nostrils")
+ | SearchQuery("Sir Robin")
+ )
+ self.assertCountEqual(searched, [self.verse1, self.verse2, self.verse0])
+
+ def test_query_invert(self):
+ searched = Line.objects.filter(
+ character=self.minstrel, dialogue__search=~SearchQuery("kneecaps")
+ )
+ self.assertCountEqual(searched, [self.verse0, self.verse2])
+
+ def test_combine_different_configs(self):
+ searched = Line.objects.filter(
+ dialogue__search=(
+ SearchQuery("cadeau", config="french")
+ | SearchQuery("nostrils", config="english")
+ )
+ )
+ self.assertCountEqual(searched, [self.french, self.verse2])
+
+ def test_combined_configs(self):
+ searched = Line.objects.filter(
+ dialogue__search=(
+ SearchQuery("nostrils", config="simple")
+ & SearchQuery("bowels", config="simple")
+ ),
+ )
+ self.assertSequenceEqual(searched, [self.verse2])
+
+ def test_combine_raw_phrase(self):
+ self.check_default_text_search_config()
+ searched = Line.objects.filter(
+ dialogue__search=(
+ SearchQuery("burn:*", search_type="raw", config="simple")
+ | SearchQuery("rode forth from Camelot", search_type="phrase")
+ )
+ )
+ self.assertCountEqual(searched, [self.verse0, self.verse1, self.verse2])
+
+ def test_query_combined_mismatch(self):
+ msg = (
+ "SearchQuery can only be combined with other SearchQuery "
+ "instances, got NoneType."
+ )
+ with self.assertRaisesMessage(TypeError, msg):
+ Line.objects.filter(dialogue__search=None | SearchQuery("kneecaps"))
+
+ with self.assertRaisesMessage(TypeError, msg):
+ Line.objects.filter(dialogue__search=None & SearchQuery("kneecaps"))
+
+
+class TestRankingAndWeights(GrailTestData, PostgreSQLTestCase):
+ def test_ranking(self):
+ searched = (
+ Line.objects.filter(character=self.minstrel)
+ .annotate(
+ rank=SearchRank(
+ SearchVector("dialogue"), SearchQuery("brave sir robin")
+ ),
+ )
+ .order_by("rank")
+ )
+ self.assertSequenceEqual(searched, [self.verse2, self.verse1, self.verse0])
+
+ def test_rank_passing_untyped_args(self):
+ searched = (
+ Line.objects.filter(character=self.minstrel)
+ .annotate(
+ rank=SearchRank("dialogue", "brave sir robin"),
+ )
+ .order_by("rank")
+ )
+ self.assertSequenceEqual(searched, [self.verse2, self.verse1, self.verse0])
+
+ def test_weights_in_vector(self):
+ vector = SearchVector("dialogue", weight="A") + SearchVector(
+ "character__name", weight="D"
+ )
+ searched = (
+ Line.objects.filter(scene=self.witch_scene)
+ .annotate(
+ rank=SearchRank(vector, SearchQuery("witch")),
+ )
+ .order_by("-rank")[:2]
+ )
+ self.assertSequenceEqual(searched, [self.crowd, self.witch])
+
+ vector = SearchVector("dialogue", weight="D") + SearchVector(
+ "character__name", weight="A"
+ )
+ searched = (
+ Line.objects.filter(scene=self.witch_scene)
+ .annotate(
+ rank=SearchRank(vector, SearchQuery("witch")),
+ )
+ .order_by("-rank")[:2]
+ )
+ self.assertSequenceEqual(searched, [self.witch, self.crowd])
+
+ def test_ranked_custom_weights(self):
+ vector = SearchVector("dialogue", weight="D") + SearchVector(
+ "character__name", weight="A"
+ )
+ weights = [1.0, 0.0, 0.0, 0.5]
+ searched = (
+ Line.objects.filter(scene=self.witch_scene)
+ .annotate(
+ rank=SearchRank(vector, SearchQuery("witch"), weights=weights),
+ )
+ .order_by("-rank")[:2]
+ )
+ self.assertSequenceEqual(searched, [self.crowd, self.witch])
+
+ def test_ranking_chaining(self):
+ searched = (
+ Line.objects.filter(character=self.minstrel)
+ .annotate(
+ rank=SearchRank(
+ SearchVector("dialogue"), SearchQuery("brave sir robin")
+ ),
+ )
+ .filter(rank__gt=0.3)
+ )
+ self.assertSequenceEqual(searched, [self.verse0])
+
+ def test_cover_density_ranking(self):
+ not_dense_verse = Line.objects.create(
+ scene=self.robin,
+ character=self.minstrel,
+ dialogue=(
+ "Bravely taking to his feet, he beat a very brave retreat. "
+ "A brave retreat brave Sir Robin."
+ ),
+ )
+ searched = (
+ Line.objects.filter(character=self.minstrel)
+ .annotate(
+ rank=SearchRank(
+ SearchVector("dialogue"),
+ SearchQuery("brave robin"),
+ cover_density=True,
+ ),
+ )
+ .order_by("rank", "-pk")
+ )
+ self.assertSequenceEqual(
+ searched,
+ [self.verse2, not_dense_verse, self.verse1, self.verse0],
+ )
+
+ def test_ranking_with_normalization(self):
+ short_verse = Line.objects.create(
+ scene=self.robin,
+ character=self.minstrel,
+ dialogue="A brave retreat brave Sir Robin.",
+ )
+ searched = (
+ Line.objects.filter(character=self.minstrel)
+ .annotate(
+ rank=SearchRank(
+ SearchVector("dialogue"),
+ SearchQuery("brave sir robin"),
+ # Divide the rank by the document length.
+ normalization=2,
+ ),
+ )
+ .order_by("rank")
+ )
+ self.assertSequenceEqual(
+ searched,
+ [self.verse2, self.verse1, self.verse0, short_verse],
+ )
+
+ def test_ranking_with_masked_normalization(self):
+ short_verse = Line.objects.create(
+ scene=self.robin,
+ character=self.minstrel,
+ dialogue="A brave retreat brave Sir Robin.",
+ )
+ searched = (
+ Line.objects.filter(character=self.minstrel)
+ .annotate(
+ rank=SearchRank(
+ SearchVector("dialogue"),
+ SearchQuery("brave sir robin"),
+ # Divide the rank by the document length and by the number of
+ # unique words in document.
+ normalization=Value(2).bitor(Value(8)),
+ ),
+ )
+ .order_by("rank")
+ )
+ self.assertSequenceEqual(
+ searched,
+ [self.verse2, self.verse1, self.verse0, short_verse],
+ )
+
+
+class SearchQueryTests(PostgreSQLSimpleTestCase):
+ def test_str(self):
+ tests = (
+ (~SearchQuery("a"), "~SearchQuery(Value('a'))"),
+ (
+ (SearchQuery("a") | SearchQuery("b"))
+ & (SearchQuery("c") | SearchQuery("d")),
+ "((SearchQuery(Value('a')) || SearchQuery(Value('b'))) && "
+ "(SearchQuery(Value('c')) || SearchQuery(Value('d'))))",
+ ),
+ (
+ SearchQuery("a") & (SearchQuery("b") | SearchQuery("c")),
+ "(SearchQuery(Value('a')) && (SearchQuery(Value('b')) || "
+ "SearchQuery(Value('c'))))",
+ ),
+ (
+ (SearchQuery("a") | SearchQuery("b")) & SearchQuery("c"),
+ "((SearchQuery(Value('a')) || SearchQuery(Value('b'))) && "
+ "SearchQuery(Value('c')))",
+ ),
+ (
+ SearchQuery("a")
+ & (SearchQuery("b") & (SearchQuery("c") | SearchQuery("d"))),
+ "(SearchQuery(Value('a')) && (SearchQuery(Value('b')) && "
+ "(SearchQuery(Value('c')) || SearchQuery(Value('d')))))",
+ ),
+ )
+ for query, expected_str in tests:
+ with self.subTest(query=query):
+ self.assertEqual(str(query), expected_str)
+
+
+class SearchHeadlineTests(GrailTestData, PostgreSQLTestCase):
+ def test_headline(self):
+ self.check_default_text_search_config()
+ searched = Line.objects.annotate(
+ headline=SearchHeadline(
+ F("dialogue"),
+ SearchQuery("brave sir robin"),
+ config=SearchConfig("english"),
+ ),
+ ).get(pk=self.verse0.pk)
+ self.assertEqual(
+ searched.headline,
+ "Robin. He was not at all afraid to be killed in nasty "
+ "ways. Brave, brave, brave, brave "
+ "Sir Robin",
+ )
+
+ def test_headline_untyped_args(self):
+ self.check_default_text_search_config()
+ searched = Line.objects.annotate(
+ headline=SearchHeadline("dialogue", "killed", config="english"),
+ ).get(pk=self.verse0.pk)
+ self.assertEqual(
+ searched.headline,
+ "Robin. He was not at all afraid to be killed in nasty "
+ "ways. Brave, brave, brave, brave Sir Robin",
+ )
+
+ def test_headline_with_config(self):
+ searched = Line.objects.annotate(
+ headline=SearchHeadline(
+ "dialogue",
+ SearchQuery("cadeaux", config="french"),
+ config="french",
+ ),
+ ).get(pk=self.french.pk)
+ self.assertEqual(
+ searched.headline,
+ "Oh. Un beau cadeau. Oui oui.",
+ )
+
+ def test_headline_with_config_from_field(self):
+ searched = Line.objects.annotate(
+ headline=SearchHeadline(
+ "dialogue",
+ SearchQuery("cadeaux", config=F("dialogue_config")),
+ config=F("dialogue_config"),
+ ),
+ ).get(pk=self.french.pk)
+ self.assertEqual(
+ searched.headline,
+ "Oh. Un beau cadeau. Oui oui.",
+ )
+
+ def test_headline_separator_options(self):
+ searched = Line.objects.annotate(
+ headline=SearchHeadline(
+ "dialogue",
+ "brave sir robin",
+ start_sel="",
+ stop_sel="",
+ ),
+ ).get(pk=self.verse0.pk)
+ self.assertEqual(
+ searched.headline,
+ "Robin. He was not at all afraid to be killed in "
+ "nasty ways. Brave, brave, brave"
+ ", brave Sir Robin",
+ )
+
+ def test_headline_highlight_all_option(self):
+ self.check_default_text_search_config()
+ searched = Line.objects.annotate(
+ headline=SearchHeadline(
+ "dialogue",
+ SearchQuery("brave sir robin", config="english"),
+ highlight_all=True,
+ ),
+ ).get(pk=self.verse0.pk)
+ self.assertIn(
+ "Bravely bold Sir Robin, rode forth from "
+ "Camelot. He was not afraid to die, o ",
+ searched.headline,
+ )
+
+ def test_headline_short_word_option(self):
+ self.check_default_text_search_config()
+ searched = Line.objects.annotate(
+ headline=SearchHeadline(
+ "dialogue",
+ SearchQuery("Camelot", config="english"),
+ short_word=5,
+ min_words=8,
+ ),
+ ).get(pk=self.verse0.pk)
+ self.assertEqual(
+ searched.headline,
+ (
+ "Camelot. He was not afraid to die, o Brave Sir Robin. He "
+ "was not at all afraid"
+ ),
+ )
+
+ def test_headline_fragments_words_options(self):
+ self.check_default_text_search_config()
+ searched = Line.objects.annotate(
+ headline=SearchHeadline(
+ "dialogue",
+ SearchQuery("brave sir robin", config="english"),
+ fragment_delimiter="...
",
+ max_fragments=4,
+ max_words=3,
+ min_words=1,
+ ),
+ ).get(pk=self.verse0.pk)
+ self.assertEqual(
+ searched.headline,
+ "Sir Robin, rode...
"
+ "Brave Sir Robin...
"
+ "Brave, brave, brave...
"
+ "brave Sir Robin",
+ )
diff --git a/testbed/django__django/tests/postgres_tests/test_signals.py b/testbed/django__django/tests/postgres_tests/test_signals.py
new file mode 100644
index 0000000000000000000000000000000000000000..b88a7e049729e34b19bd12ac710477b288a3f578
--- /dev/null
+++ b/testbed/django__django/tests/postgres_tests/test_signals.py
@@ -0,0 +1,44 @@
+from django.db import connection
+
+from . import PostgreSQLTestCase
+
+try:
+ from django.contrib.postgres.signals import (
+ get_citext_oids,
+ get_hstore_oids,
+ register_type_handlers,
+ )
+except ImportError:
+ pass # psycopg isn't installed.
+
+
+class OIDTests(PostgreSQLTestCase):
+ def assertOIDs(self, oids):
+ self.assertIsInstance(oids, tuple)
+ self.assertGreater(len(oids), 0)
+ self.assertTrue(all(isinstance(oid, int) for oid in oids))
+
+ def test_hstore_cache(self):
+ get_hstore_oids(connection.alias)
+ with self.assertNumQueries(0):
+ get_hstore_oids(connection.alias)
+
+ def test_citext_cache(self):
+ get_citext_oids(connection.alias)
+ with self.assertNumQueries(0):
+ get_citext_oids(connection.alias)
+
+ def test_hstore_values(self):
+ oids, array_oids = get_hstore_oids(connection.alias)
+ self.assertOIDs(oids)
+ self.assertOIDs(array_oids)
+
+ def test_citext_values(self):
+ oids, citext_oids = get_citext_oids(connection.alias)
+ self.assertOIDs(oids)
+ self.assertOIDs(citext_oids)
+
+ def test_register_type_handlers_no_db(self):
+ """Registering type handlers for the nodb connection does nothing."""
+ with connection._nodb_cursor() as cursor:
+ register_type_handlers(cursor.db)
diff --git a/testbed/django__django/tests/postgres_tests/test_trigram.py b/testbed/django__django/tests/postgres_tests/test_trigram.py
new file mode 100644
index 0000000000000000000000000000000000000000..812403a32437e15fe7ecef28ed6204664df4254c
--- /dev/null
+++ b/testbed/django__django/tests/postgres_tests/test_trigram.py
@@ -0,0 +1,158 @@
+from . import PostgreSQLTestCase
+from .models import CharFieldModel, TextFieldModel
+
+try:
+ from django.contrib.postgres.search import (
+ TrigramDistance,
+ TrigramSimilarity,
+ TrigramStrictWordDistance,
+ TrigramStrictWordSimilarity,
+ TrigramWordDistance,
+ TrigramWordSimilarity,
+ )
+except ImportError:
+ pass
+
+
+class TrigramTest(PostgreSQLTestCase):
+ Model = CharFieldModel
+
+ @classmethod
+ def setUpTestData(cls):
+ cls.Model.objects.bulk_create(
+ [
+ cls.Model(field="Matthew"),
+ cls.Model(field="Cat sat on mat."),
+ cls.Model(field="Dog sat on rug."),
+ ]
+ )
+
+ def test_trigram_search(self):
+ self.assertQuerySetEqual(
+ self.Model.objects.filter(field__trigram_similar="Mathew"),
+ ["Matthew"],
+ transform=lambda instance: instance.field,
+ )
+
+ def test_trigram_word_search(self):
+ obj = self.Model.objects.create(
+ field="Gumby rides on the path of Middlesbrough",
+ )
+ self.assertSequenceEqual(
+ self.Model.objects.filter(field__trigram_word_similar="Middlesborough"),
+ [obj],
+ )
+ self.assertSequenceEqual(
+ self.Model.objects.filter(field__trigram_word_similar="Middle"),
+ [obj],
+ )
+
+ def test_trigram_strict_word_search_matched(self):
+ obj = self.Model.objects.create(
+ field="Gumby rides on the path of Middlesbrough",
+ )
+ self.assertSequenceEqual(
+ self.Model.objects.filter(
+ field__trigram_strict_word_similar="Middlesborough"
+ ),
+ [obj],
+ )
+ self.assertSequenceEqual(
+ self.Model.objects.filter(field__trigram_strict_word_similar="Middle"),
+ [],
+ )
+
+ def test_trigram_similarity(self):
+ search = "Bat sat on cat."
+ # Round result of similarity because PostgreSQL uses greater precision.
+ self.assertQuerySetEqual(
+ self.Model.objects.filter(
+ field__trigram_similar=search,
+ )
+ .annotate(similarity=TrigramSimilarity("field", search))
+ .order_by("-similarity"),
+ [("Cat sat on mat.", 0.625), ("Dog sat on rug.", 0.333333)],
+ transform=lambda instance: (instance.field, round(instance.similarity, 6)),
+ ordered=True,
+ )
+
+ def test_trigram_word_similarity(self):
+ search = "mat"
+ self.assertSequenceEqual(
+ self.Model.objects.filter(
+ field__trigram_word_similar=search,
+ )
+ .annotate(
+ word_similarity=TrigramWordSimilarity(search, "field"),
+ )
+ .values("field", "word_similarity")
+ .order_by("-word_similarity"),
+ [
+ {"field": "Cat sat on mat.", "word_similarity": 1.0},
+ {"field": "Matthew", "word_similarity": 0.75},
+ ],
+ )
+
+ def test_trigram_strict_word_similarity(self):
+ search = "matt"
+ self.assertSequenceEqual(
+ self.Model.objects.filter(field__trigram_word_similar=search)
+ .annotate(word_similarity=TrigramStrictWordSimilarity(search, "field"))
+ .values("field", "word_similarity")
+ .order_by("-word_similarity"),
+ [
+ {"field": "Cat sat on mat.", "word_similarity": 0.5},
+ {"field": "Matthew", "word_similarity": 0.44444445},
+ ],
+ )
+
+ def test_trigram_similarity_alternate(self):
+ # Round result of distance because PostgreSQL uses greater precision.
+ self.assertQuerySetEqual(
+ self.Model.objects.annotate(
+ distance=TrigramDistance("field", "Bat sat on cat."),
+ )
+ .filter(distance__lte=0.7)
+ .order_by("distance"),
+ [("Cat sat on mat.", 0.375), ("Dog sat on rug.", 0.666667)],
+ transform=lambda instance: (instance.field, round(instance.distance, 6)),
+ ordered=True,
+ )
+
+ def test_trigram_word_similarity_alternate(self):
+ self.assertSequenceEqual(
+ self.Model.objects.annotate(
+ word_distance=TrigramWordDistance("mat", "field"),
+ )
+ .filter(
+ word_distance__lte=0.7,
+ )
+ .values("field", "word_distance")
+ .order_by("word_distance"),
+ [
+ {"field": "Cat sat on mat.", "word_distance": 0},
+ {"field": "Matthew", "word_distance": 0.25},
+ ],
+ )
+
+ def test_trigram_strict_word_distance(self):
+ self.assertSequenceEqual(
+ self.Model.objects.annotate(
+ word_distance=TrigramStrictWordDistance("matt", "field"),
+ )
+ .filter(word_distance__lte=0.7)
+ .values("field", "word_distance")
+ .order_by("word_distance"),
+ [
+ {"field": "Cat sat on mat.", "word_distance": 0.5},
+ {"field": "Matthew", "word_distance": 0.5555556},
+ ],
+ )
+
+
+class TrigramTextFieldTest(TrigramTest):
+ """
+ TextField has the same behavior as CharField regarding trigram lookups.
+ """
+
+ Model = TextFieldModel
diff --git a/testbed/django__django/tests/postgres_tests/test_unaccent.py b/testbed/django__django/tests/postgres_tests/test_unaccent.py
new file mode 100644
index 0000000000000000000000000000000000000000..4c0bca762bd47139ed5b77df6316b1256a591bf9
--- /dev/null
+++ b/testbed/django__django/tests/postgres_tests/test_unaccent.py
@@ -0,0 +1,79 @@
+from django.db import connection
+
+from . import PostgreSQLTestCase
+from .models import CharFieldModel, TextFieldModel
+
+
+class UnaccentTest(PostgreSQLTestCase):
+ Model = CharFieldModel
+
+ @classmethod
+ def setUpTestData(cls):
+ cls.Model.objects.bulk_create(
+ [
+ cls.Model(field="àéÖ"),
+ cls.Model(field="aeO"),
+ cls.Model(field="aeo"),
+ ]
+ )
+
+ def test_unaccent(self):
+ self.assertQuerySetEqual(
+ self.Model.objects.filter(field__unaccent="aeO"),
+ ["àéÖ", "aeO"],
+ transform=lambda instance: instance.field,
+ ordered=False,
+ )
+
+ def test_unaccent_chained(self):
+ """
+ Unaccent can be used chained with a lookup (which should be the case
+ since unaccent implements the Transform API)
+ """
+ self.assertQuerySetEqual(
+ self.Model.objects.filter(field__unaccent__iexact="aeO"),
+ ["àéÖ", "aeO", "aeo"],
+ transform=lambda instance: instance.field,
+ ordered=False,
+ )
+ self.assertQuerySetEqual(
+ self.Model.objects.filter(field__unaccent__endswith="éÖ"),
+ ["àéÖ", "aeO"],
+ transform=lambda instance: instance.field,
+ ordered=False,
+ )
+
+ def test_unaccent_with_conforming_strings_off(self):
+ """SQL is valid when standard_conforming_strings is off."""
+ with connection.cursor() as cursor:
+ cursor.execute("SHOW standard_conforming_strings")
+ disable_conforming_strings = cursor.fetchall()[0][0] == "on"
+ if disable_conforming_strings:
+ cursor.execute("SET standard_conforming_strings TO off")
+ try:
+ self.assertQuerySetEqual(
+ self.Model.objects.filter(field__unaccent__endswith="éÖ"),
+ ["àéÖ", "aeO"],
+ transform=lambda instance: instance.field,
+ ordered=False,
+ )
+ finally:
+ if disable_conforming_strings:
+ cursor.execute("SET standard_conforming_strings TO on")
+
+ def test_unaccent_accentuated_needle(self):
+ self.assertQuerySetEqual(
+ self.Model.objects.filter(field__unaccent="aéÖ"),
+ ["àéÖ", "aeO"],
+ transform=lambda instance: instance.field,
+ ordered=False,
+ )
+
+
+class UnaccentTextFieldTest(UnaccentTest):
+ """
+ TextField should have the exact same behavior as CharField
+ regarding unaccent lookups.
+ """
+
+ Model = TextFieldModel
diff --git a/testbed/django__django/tests/prefetch_related/__init__.py b/testbed/django__django/tests/prefetch_related/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testbed/django__django/tests/prefetch_related/models.py b/testbed/django__django/tests/prefetch_related/models.py
new file mode 100644
index 0000000000000000000000000000000000000000..0d9dbe6066c0b324ca59ab5cd015debf86a3af57
--- /dev/null
+++ b/testbed/django__django/tests/prefetch_related/models.py
@@ -0,0 +1,315 @@
+import uuid
+
+from django.contrib.contenttypes.fields import GenericForeignKey, GenericRelation
+from django.contrib.contenttypes.models import ContentType
+from django.db import models
+from django.db.models.query import ModelIterable
+from django.utils.functional import cached_property
+
+
+class Author(models.Model):
+ name = models.CharField(max_length=50, unique=True)
+ first_book = models.ForeignKey(
+ "Book", models.CASCADE, related_name="first_time_authors"
+ )
+ favorite_authors = models.ManyToManyField(
+ "self", through="FavoriteAuthors", symmetrical=False, related_name="favors_me"
+ )
+
+ class Meta:
+ ordering = ["id"]
+
+ def __str__(self):
+ return self.name
+
+
+class AuthorWithAge(Author):
+ author = models.OneToOneField(Author, models.CASCADE, parent_link=True)
+ age = models.IntegerField()
+
+
+class FavoriteAuthors(models.Model):
+ author = models.ForeignKey(
+ Author, models.CASCADE, to_field="name", related_name="i_like"
+ )
+ likes_author = models.ForeignKey(
+ Author, models.CASCADE, to_field="name", related_name="likes_me"
+ )
+
+ class Meta:
+ ordering = ["id"]
+
+
+class AuthorAddress(models.Model):
+ author = models.ForeignKey(
+ Author, models.CASCADE, to_field="name", related_name="addresses"
+ )
+ address = models.TextField()
+
+ class Meta:
+ ordering = ["id"]
+
+
+class Book(models.Model):
+ title = models.CharField(max_length=255)
+ authors = models.ManyToManyField(Author, related_name="books")
+
+ class Meta:
+ ordering = ["id"]
+
+
+class BookWithYear(Book):
+ book = models.OneToOneField(Book, models.CASCADE, parent_link=True)
+ published_year = models.IntegerField()
+ aged_authors = models.ManyToManyField(AuthorWithAge, related_name="books_with_year")
+
+
+class Bio(models.Model):
+ author = models.OneToOneField(
+ Author,
+ models.CASCADE,
+ primary_key=True,
+ to_field="name",
+ )
+ books = models.ManyToManyField(Book, blank=True)
+
+
+class Reader(models.Model):
+ name = models.CharField(max_length=50)
+ books_read = models.ManyToManyField(Book, related_name="read_by")
+
+ class Meta:
+ ordering = ["id"]
+
+ def __str__(self):
+ return self.name
+
+
+class BookReview(models.Model):
+ # Intentionally does not have a related name.
+ book = models.ForeignKey(BookWithYear, models.CASCADE, null=True)
+ notes = models.TextField(null=True, blank=True)
+
+
+# Models for default manager tests
+
+
+class Qualification(models.Model):
+ name = models.CharField(max_length=10)
+
+ class Meta:
+ ordering = ["id"]
+
+
+class ModelIterableSubclass(ModelIterable):
+ pass
+
+
+class TeacherQuerySet(models.QuerySet):
+ def __init__(self, *args, **kwargs):
+ super().__init__(*args, **kwargs)
+ self._iterable_class = ModelIterableSubclass
+
+
+class TeacherManager(models.Manager):
+ def get_queryset(self):
+ return super().get_queryset().prefetch_related("qualifications")
+
+
+class Teacher(models.Model):
+ name = models.CharField(max_length=50)
+ qualifications = models.ManyToManyField(Qualification)
+
+ objects = TeacherManager()
+ objects_custom = TeacherQuerySet.as_manager()
+
+ class Meta:
+ ordering = ["id"]
+
+ def __str__(self):
+ return "%s (%s)" % (
+ self.name,
+ ", ".join(q.name for q in self.qualifications.all()),
+ )
+
+
+class Department(models.Model):
+ name = models.CharField(max_length=50)
+ teachers = models.ManyToManyField(Teacher)
+
+ class Meta:
+ ordering = ["id"]
+
+
+# GenericRelation/GenericForeignKey tests
+
+
+class TaggedItem(models.Model):
+ tag = models.SlugField()
+ content_type = models.ForeignKey(
+ ContentType,
+ models.CASCADE,
+ related_name="taggeditem_set2",
+ )
+ object_id = models.PositiveIntegerField()
+ content_object = GenericForeignKey("content_type", "object_id")
+ created_by_ct = models.ForeignKey(
+ ContentType,
+ models.SET_NULL,
+ null=True,
+ related_name="taggeditem_set3",
+ )
+ created_by_fkey = models.PositiveIntegerField(null=True)
+ created_by = GenericForeignKey(
+ "created_by_ct",
+ "created_by_fkey",
+ )
+ favorite_ct = models.ForeignKey(
+ ContentType,
+ models.SET_NULL,
+ null=True,
+ related_name="taggeditem_set4",
+ )
+ favorite_fkey = models.CharField(max_length=64, null=True)
+ favorite = GenericForeignKey("favorite_ct", "favorite_fkey")
+
+ class Meta:
+ ordering = ["id"]
+
+
+class Article(models.Model):
+ id = models.UUIDField(primary_key=True, default=uuid.uuid4, editable=False)
+ name = models.CharField(max_length=20)
+
+
+class Bookmark(models.Model):
+ url = models.URLField()
+ tags = GenericRelation(TaggedItem, related_query_name="bookmarks")
+ favorite_tags = GenericRelation(
+ TaggedItem,
+ content_type_field="favorite_ct",
+ object_id_field="favorite_fkey",
+ related_query_name="favorite_bookmarks",
+ )
+
+ class Meta:
+ ordering = ["id"]
+
+
+class Comment(models.Model):
+ comment = models.TextField()
+
+ # Content-object field
+ content_type = models.ForeignKey(ContentType, models.CASCADE, null=True)
+ object_pk = models.TextField()
+ content_object = GenericForeignKey(ct_field="content_type", fk_field="object_pk")
+ content_type_uuid = models.ForeignKey(
+ ContentType, models.CASCADE, related_name="comments", null=True
+ )
+ object_pk_uuid = models.TextField()
+ content_object_uuid = GenericForeignKey(
+ ct_field="content_type_uuid", fk_field="object_pk_uuid"
+ )
+
+ class Meta:
+ ordering = ["id"]
+
+
+# Models for lookup ordering tests
+
+
+class House(models.Model):
+ name = models.CharField(max_length=50)
+ address = models.CharField(max_length=255)
+ owner = models.ForeignKey("Person", models.SET_NULL, null=True)
+ main_room = models.OneToOneField(
+ "Room", models.SET_NULL, related_name="main_room_of", null=True
+ )
+
+ class Meta:
+ ordering = ["id"]
+
+
+class Room(models.Model):
+ name = models.CharField(max_length=50)
+ house = models.ForeignKey(House, models.CASCADE, related_name="rooms")
+
+ class Meta:
+ ordering = ["id"]
+
+
+class Person(models.Model):
+ name = models.CharField(max_length=50)
+ houses = models.ManyToManyField(House, related_name="occupants")
+
+ @property
+ def primary_house(self):
+ # Assume business logic forces every person to have at least one house.
+ return sorted(self.houses.all(), key=lambda house: -house.rooms.count())[0]
+
+ @property
+ def all_houses(self):
+ return list(self.houses.all())
+
+ @cached_property
+ def cached_all_houses(self):
+ return self.all_houses
+
+ class Meta:
+ ordering = ["id"]
+
+
+# Models for nullable FK tests
+
+
+class Employee(models.Model):
+ name = models.CharField(max_length=50)
+ boss = models.ForeignKey("self", models.SET_NULL, null=True, related_name="serfs")
+
+ class Meta:
+ ordering = ["id"]
+
+
+# Ticket #19607
+
+
+class LessonEntry(models.Model):
+ name1 = models.CharField(max_length=200)
+ name2 = models.CharField(max_length=200)
+
+
+class WordEntry(models.Model):
+ lesson_entry = models.ForeignKey(LessonEntry, models.CASCADE)
+ name = models.CharField(max_length=200)
+
+
+# Ticket #21410: Regression when related_name="+"
+
+
+class Author2(models.Model):
+ name = models.CharField(max_length=50, unique=True)
+ first_book = models.ForeignKey(
+ "Book", models.CASCADE, related_name="first_time_authors+"
+ )
+ favorite_books = models.ManyToManyField("Book", related_name="+")
+
+ class Meta:
+ ordering = ["id"]
+
+
+# Models for many-to-many with UUID pk test:
+
+
+class Pet(models.Model):
+ id = models.UUIDField(primary_key=True, default=uuid.uuid4, editable=False)
+ name = models.CharField(max_length=20)
+ people = models.ManyToManyField(Person, related_name="pets")
+
+
+class Flea(models.Model):
+ id = models.UUIDField(primary_key=True, default=uuid.uuid4, editable=False)
+ current_room = models.ForeignKey(
+ Room, models.SET_NULL, related_name="fleas", null=True
+ )
+ pets_visited = models.ManyToManyField(Pet, related_name="fleas_hosted")
+ people_visited = models.ManyToManyField(Person, related_name="fleas_hosted")
diff --git a/testbed/django__django/tests/prefetch_related/test_prefetch_related_objects.py b/testbed/django__django/tests/prefetch_related/test_prefetch_related_objects.py
new file mode 100644
index 0000000000000000000000000000000000000000..ca1f904c5205e757e9fb25eeefd3359eb19cf36b
--- /dev/null
+++ b/testbed/django__django/tests/prefetch_related/test_prefetch_related_objects.py
@@ -0,0 +1,157 @@
+from django.db.models import Prefetch, prefetch_related_objects
+from django.test import TestCase
+
+from .models import Author, Book, Reader
+
+
+class PrefetchRelatedObjectsTests(TestCase):
+ """
+ Since prefetch_related_objects() is just the inner part of
+ prefetch_related(), only do basic tests to ensure its API hasn't changed.
+ """
+
+ @classmethod
+ def setUpTestData(cls):
+ cls.book1 = Book.objects.create(title="Poems")
+ cls.book2 = Book.objects.create(title="Jane Eyre")
+ cls.book3 = Book.objects.create(title="Wuthering Heights")
+ cls.book4 = Book.objects.create(title="Sense and Sensibility")
+
+ cls.author1 = Author.objects.create(name="Charlotte", first_book=cls.book1)
+ cls.author2 = Author.objects.create(name="Anne", first_book=cls.book1)
+ cls.author3 = Author.objects.create(name="Emily", first_book=cls.book1)
+ cls.author4 = Author.objects.create(name="Jane", first_book=cls.book4)
+
+ cls.book1.authors.add(cls.author1, cls.author2, cls.author3)
+ cls.book2.authors.add(cls.author1)
+ cls.book3.authors.add(cls.author3)
+ cls.book4.authors.add(cls.author4)
+
+ cls.reader1 = Reader.objects.create(name="Amy")
+ cls.reader2 = Reader.objects.create(name="Belinda")
+
+ cls.reader1.books_read.add(cls.book1, cls.book4)
+ cls.reader2.books_read.add(cls.book2, cls.book4)
+
+ def test_unknown(self):
+ book1 = Book.objects.get(id=self.book1.id)
+ with self.assertRaises(AttributeError):
+ prefetch_related_objects([book1], "unknown_attribute")
+
+ def test_m2m_forward(self):
+ book1 = Book.objects.get(id=self.book1.id)
+ with self.assertNumQueries(1):
+ prefetch_related_objects([book1], "authors")
+
+ with self.assertNumQueries(0):
+ self.assertCountEqual(
+ book1.authors.all(), [self.author1, self.author2, self.author3]
+ )
+
+ def test_m2m_reverse(self):
+ author1 = Author.objects.get(id=self.author1.id)
+ with self.assertNumQueries(1):
+ prefetch_related_objects([author1], "books")
+
+ with self.assertNumQueries(0):
+ self.assertCountEqual(author1.books.all(), [self.book1, self.book2])
+
+ def test_foreignkey_forward(self):
+ authors = list(Author.objects.all())
+ with self.assertNumQueries(1):
+ prefetch_related_objects(authors, "first_book")
+
+ with self.assertNumQueries(0):
+ [author.first_book for author in authors]
+
+ def test_foreignkey_reverse(self):
+ books = list(Book.objects.all())
+ with self.assertNumQueries(1):
+ prefetch_related_objects(books, "first_time_authors")
+
+ with self.assertNumQueries(0):
+ [list(book.first_time_authors.all()) for book in books]
+
+ def test_m2m_then_m2m(self):
+ """A m2m can be followed through another m2m."""
+ authors = list(Author.objects.all())
+ with self.assertNumQueries(2):
+ prefetch_related_objects(authors, "books__read_by")
+
+ with self.assertNumQueries(0):
+ self.assertEqual(
+ [
+ [[str(r) for r in b.read_by.all()] for b in a.books.all()]
+ for a in authors
+ ],
+ [
+ [["Amy"], ["Belinda"]], # Charlotte - Poems, Jane Eyre
+ [["Amy"]], # Anne - Poems
+ [["Amy"], []], # Emily - Poems, Wuthering Heights
+ [["Amy", "Belinda"]], # Jane - Sense and Sense
+ ],
+ )
+
+ def test_prefetch_object(self):
+ book1 = Book.objects.get(id=self.book1.id)
+ with self.assertNumQueries(1):
+ prefetch_related_objects([book1], Prefetch("authors"))
+
+ with self.assertNumQueries(0):
+ self.assertCountEqual(
+ book1.authors.all(), [self.author1, self.author2, self.author3]
+ )
+
+ def test_prefetch_object_twice(self):
+ book1 = Book.objects.get(id=self.book1.id)
+ book2 = Book.objects.get(id=self.book2.id)
+ with self.assertNumQueries(1):
+ prefetch_related_objects([book1], Prefetch("authors"))
+ with self.assertNumQueries(1):
+ prefetch_related_objects([book1, book2], Prefetch("authors"))
+ with self.assertNumQueries(0):
+ self.assertCountEqual(book2.authors.all(), [self.author1])
+
+ def test_prefetch_object_to_attr(self):
+ book1 = Book.objects.get(id=self.book1.id)
+ with self.assertNumQueries(1):
+ prefetch_related_objects(
+ [book1], Prefetch("authors", to_attr="the_authors")
+ )
+
+ with self.assertNumQueries(0):
+ self.assertCountEqual(
+ book1.the_authors, [self.author1, self.author2, self.author3]
+ )
+
+ def test_prefetch_object_to_attr_twice(self):
+ book1 = Book.objects.get(id=self.book1.id)
+ book2 = Book.objects.get(id=self.book2.id)
+ with self.assertNumQueries(1):
+ prefetch_related_objects(
+ [book1],
+ Prefetch("authors", to_attr="the_authors"),
+ )
+ with self.assertNumQueries(1):
+ prefetch_related_objects(
+ [book1, book2],
+ Prefetch("authors", to_attr="the_authors"),
+ )
+ with self.assertNumQueries(0):
+ self.assertCountEqual(book2.the_authors, [self.author1])
+
+ def test_prefetch_queryset(self):
+ book1 = Book.objects.get(id=self.book1.id)
+ with self.assertNumQueries(1):
+ prefetch_related_objects(
+ [book1],
+ Prefetch(
+ "authors",
+ queryset=Author.objects.filter(
+ id__in=[self.author1.id, self.author2.id]
+ ),
+ ),
+ )
+
+ with self.assertNumQueries(0):
+ self.assertCountEqual(book1.authors.all(), [self.author1, self.author2])
diff --git a/testbed/django__django/tests/prefetch_related/test_uuid.py b/testbed/django__django/tests/prefetch_related/test_uuid.py
new file mode 100644
index 0000000000000000000000000000000000000000..f22b2158a5be01089327cef2e9afaa526c7f1f7b
--- /dev/null
+++ b/testbed/django__django/tests/prefetch_related/test_uuid.py
@@ -0,0 +1,118 @@
+from django.test import TestCase
+
+from .models import Flea, House, Person, Pet, Room
+
+
+class UUIDPrefetchRelated(TestCase):
+ def test_prefetch_related_from_uuid_model(self):
+ Pet.objects.create(name="Fifi").people.add(
+ Person.objects.create(name="Ellen"),
+ Person.objects.create(name="George"),
+ )
+
+ with self.assertNumQueries(2):
+ pet = Pet.objects.prefetch_related("people").get(name="Fifi")
+ with self.assertNumQueries(0):
+ self.assertEqual(2, len(pet.people.all()))
+
+ def test_prefetch_related_to_uuid_model(self):
+ Person.objects.create(name="Bella").pets.add(
+ Pet.objects.create(name="Socks"),
+ Pet.objects.create(name="Coffee"),
+ )
+
+ with self.assertNumQueries(2):
+ person = Person.objects.prefetch_related("pets").get(name="Bella")
+ with self.assertNumQueries(0):
+ self.assertEqual(2, len(person.pets.all()))
+
+ def test_prefetch_related_from_uuid_model_to_uuid_model(self):
+ fleas = [Flea.objects.create() for i in range(3)]
+ Pet.objects.create(name="Fifi").fleas_hosted.add(*fleas)
+ Pet.objects.create(name="Bobo").fleas_hosted.add(*fleas)
+
+ with self.assertNumQueries(2):
+ pet = Pet.objects.prefetch_related("fleas_hosted").get(name="Fifi")
+ with self.assertNumQueries(0):
+ self.assertEqual(3, len(pet.fleas_hosted.all()))
+
+ with self.assertNumQueries(2):
+ flea = Flea.objects.prefetch_related("pets_visited").get(pk=fleas[0].pk)
+ with self.assertNumQueries(0):
+ self.assertEqual(2, len(flea.pets_visited.all()))
+
+ def test_prefetch_related_from_uuid_model_to_uuid_model_with_values_flat(self):
+ pet = Pet.objects.create(name="Fifi")
+ pet.people.add(
+ Person.objects.create(name="Ellen"),
+ Person.objects.create(name="George"),
+ )
+ self.assertSequenceEqual(
+ Pet.objects.prefetch_related("fleas_hosted").values_list("id", flat=True),
+ [pet.id],
+ )
+
+
+class UUIDPrefetchRelatedLookups(TestCase):
+ @classmethod
+ def setUpTestData(cls):
+ house = House.objects.create(name="Redwood", address="Arcata")
+ room = Room.objects.create(name="Racoon", house=house)
+ fleas = [Flea.objects.create(current_room=room) for i in range(3)]
+ pet = Pet.objects.create(name="Spooky")
+ pet.fleas_hosted.add(*fleas)
+ person = Person.objects.create(name="Bob")
+ person.houses.add(house)
+ person.pets.add(pet)
+ person.fleas_hosted.add(*fleas)
+
+ def test_from_uuid_pk_lookup_uuid_pk_integer_pk(self):
+ # From uuid-pk model, prefetch .:
+ with self.assertNumQueries(4):
+ spooky = Pet.objects.prefetch_related(
+ "fleas_hosted__current_room__house"
+ ).get(name="Spooky")
+ with self.assertNumQueries(0):
+ self.assertEqual("Racoon", spooky.fleas_hosted.all()[0].current_room.name)
+
+ def test_from_uuid_pk_lookup_integer_pk2_uuid_pk2(self):
+ # From uuid-pk model, prefetch
+ # ...:
+ with self.assertNumQueries(5):
+ spooky = Pet.objects.prefetch_related("people__houses__rooms__fleas").get(
+ name="Spooky"
+ )
+ with self.assertNumQueries(0):
+ self.assertEqual(
+ 3,
+ len(spooky.people.all()[0].houses.all()[0].rooms.all()[0].fleas.all()),
+ )
+
+ def test_from_integer_pk_lookup_uuid_pk_integer_pk(self):
+ # From integer-pk model, prefetch .:
+ with self.assertNumQueries(3):
+ racoon = Room.objects.prefetch_related("fleas__people_visited").get(
+ name="Racoon"
+ )
+ with self.assertNumQueries(0):
+ self.assertEqual("Bob", racoon.fleas.all()[0].people_visited.all()[0].name)
+
+ def test_from_integer_pk_lookup_integer_pk_uuid_pk(self):
+ # From integer-pk model, prefetch .:
+ with self.assertNumQueries(3):
+ redwood = House.objects.prefetch_related("rooms__fleas").get(name="Redwood")
+ with self.assertNumQueries(0):
+ self.assertEqual(3, len(redwood.rooms.all()[0].fleas.all()))
+
+ def test_from_integer_pk_lookup_integer_pk_uuid_pk_uuid_pk(self):
+ # From integer-pk model, prefetch
+ # ..:
+ with self.assertNumQueries(4):
+ redwood = House.objects.prefetch_related("rooms__fleas__pets_visited").get(
+ name="Redwood"
+ )
+ with self.assertNumQueries(0):
+ self.assertEqual(
+ "Spooky",
+ redwood.rooms.all()[0].fleas.all()[0].pets_visited.all()[0].name,
+ )
diff --git a/testbed/django__django/tests/prefetch_related/tests.py b/testbed/django__django/tests/prefetch_related/tests.py
new file mode 100644
index 0000000000000000000000000000000000000000..c8b9a9538b03222dfbaa728c19c466372109f020
--- /dev/null
+++ b/testbed/django__django/tests/prefetch_related/tests.py
@@ -0,0 +1,1971 @@
+from unittest import mock
+
+from django.contrib.contenttypes.models import ContentType
+from django.core.exceptions import ObjectDoesNotExist
+from django.db import NotSupportedError, connection
+from django.db.models import Prefetch, QuerySet, prefetch_related_objects
+from django.db.models.query import get_prefetcher
+from django.db.models.sql import Query
+from django.test import (
+ TestCase,
+ override_settings,
+ skipIfDBFeature,
+ skipUnlessDBFeature,
+)
+from django.test.utils import CaptureQueriesContext
+
+from .models import (
+ Article,
+ Author,
+ Author2,
+ AuthorAddress,
+ AuthorWithAge,
+ Bio,
+ Book,
+ Bookmark,
+ BookReview,
+ BookWithYear,
+ Comment,
+ Department,
+ Employee,
+ FavoriteAuthors,
+ House,
+ LessonEntry,
+ ModelIterableSubclass,
+ Person,
+ Qualification,
+ Reader,
+ Room,
+ TaggedItem,
+ Teacher,
+ WordEntry,
+)
+
+
+class TestDataMixin:
+ @classmethod
+ def setUpTestData(cls):
+ cls.book1 = Book.objects.create(title="Poems")
+ cls.book2 = Book.objects.create(title="Jane Eyre")
+ cls.book3 = Book.objects.create(title="Wuthering Heights")
+ cls.book4 = Book.objects.create(title="Sense and Sensibility")
+
+ cls.author1 = Author.objects.create(name="Charlotte", first_book=cls.book1)
+ cls.author2 = Author.objects.create(name="Anne", first_book=cls.book1)
+ cls.author3 = Author.objects.create(name="Emily", first_book=cls.book1)
+ cls.author4 = Author.objects.create(name="Jane", first_book=cls.book4)
+
+ cls.book1.authors.add(cls.author1, cls.author2, cls.author3)
+ cls.book2.authors.add(cls.author1)
+ cls.book3.authors.add(cls.author3)
+ cls.book4.authors.add(cls.author4)
+
+ cls.reader1 = Reader.objects.create(name="Amy")
+ cls.reader2 = Reader.objects.create(name="Belinda")
+
+ cls.reader1.books_read.add(cls.book1, cls.book4)
+ cls.reader2.books_read.add(cls.book2, cls.book4)
+
+
+class PrefetchRelatedTests(TestDataMixin, TestCase):
+ def assertWhereContains(self, sql, needle):
+ where_idx = sql.index("WHERE")
+ self.assertEqual(
+ sql.count(str(needle), where_idx),
+ 1,
+ msg="WHERE clause doesn't contain %s, actual SQL: %s"
+ % (needle, sql[where_idx:]),
+ )
+
+ def test_m2m_forward(self):
+ with self.assertNumQueries(2):
+ lists = [
+ list(b.authors.all()) for b in Book.objects.prefetch_related("authors")
+ ]
+
+ normal_lists = [list(b.authors.all()) for b in Book.objects.all()]
+ self.assertEqual(lists, normal_lists)
+
+ def test_m2m_reverse(self):
+ with self.assertNumQueries(2):
+ lists = [
+ list(a.books.all()) for a in Author.objects.prefetch_related("books")
+ ]
+
+ normal_lists = [list(a.books.all()) for a in Author.objects.all()]
+ self.assertEqual(lists, normal_lists)
+
+ def test_foreignkey_forward(self):
+ with self.assertNumQueries(2):
+ books = [
+ a.first_book for a in Author.objects.prefetch_related("first_book")
+ ]
+
+ normal_books = [a.first_book for a in Author.objects.all()]
+ self.assertEqual(books, normal_books)
+
+ def test_foreignkey_reverse(self):
+ with self.assertNumQueries(2):
+ [
+ list(b.first_time_authors.all())
+ for b in Book.objects.prefetch_related("first_time_authors")
+ ]
+
+ self.assertSequenceEqual(self.book2.authors.all(), [self.author1])
+
+ def test_onetoone_reverse_no_match(self):
+ # Regression for #17439
+ with self.assertNumQueries(2):
+ book = Book.objects.prefetch_related("bookwithyear").all()[0]
+ with self.assertNumQueries(0):
+ with self.assertRaises(BookWithYear.DoesNotExist):
+ book.bookwithyear
+
+ def test_onetoone_reverse_with_to_field_pk(self):
+ """
+ A model (Bio) with a OneToOneField primary key (author) that references
+ a non-pk field (name) on the related model (Author) is prefetchable.
+ """
+ Bio.objects.bulk_create(
+ [
+ Bio(author=self.author1),
+ Bio(author=self.author2),
+ Bio(author=self.author3),
+ ]
+ )
+ authors = Author.objects.filter(
+ name__in=[self.author1, self.author2, self.author3],
+ ).prefetch_related("bio")
+ with self.assertNumQueries(2):
+ for author in authors:
+ self.assertEqual(author.name, author.bio.author.name)
+
+ def test_survives_clone(self):
+ with self.assertNumQueries(2):
+ [
+ list(b.first_time_authors.all())
+ for b in Book.objects.prefetch_related("first_time_authors").exclude(
+ id=1000
+ )
+ ]
+
+ def test_len(self):
+ with self.assertNumQueries(2):
+ qs = Book.objects.prefetch_related("first_time_authors")
+ len(qs)
+ [list(b.first_time_authors.all()) for b in qs]
+
+ def test_bool(self):
+ with self.assertNumQueries(2):
+ qs = Book.objects.prefetch_related("first_time_authors")
+ bool(qs)
+ [list(b.first_time_authors.all()) for b in qs]
+
+ def test_count(self):
+ with self.assertNumQueries(2):
+ qs = Book.objects.prefetch_related("first_time_authors")
+ [b.first_time_authors.count() for b in qs]
+
+ def test_exists(self):
+ with self.assertNumQueries(2):
+ qs = Book.objects.prefetch_related("first_time_authors")
+ [b.first_time_authors.exists() for b in qs]
+
+ def test_in_and_prefetch_related(self):
+ """
+ Regression test for #20242 - QuerySet "in" didn't work the first time
+ when using prefetch_related. This was fixed by the removal of chunked
+ reads from QuerySet iteration in
+ 70679243d1786e03557c28929f9762a119e3ac14.
+ """
+ qs = Book.objects.prefetch_related("first_time_authors")
+ self.assertIn(qs[0], qs)
+
+ def test_clear(self):
+ with self.assertNumQueries(5):
+ with_prefetch = Author.objects.prefetch_related("books")
+ without_prefetch = with_prefetch.prefetch_related(None)
+ [list(a.books.all()) for a in without_prefetch]
+
+ def test_m2m_then_m2m(self):
+ """A m2m can be followed through another m2m."""
+ with self.assertNumQueries(3):
+ qs = Author.objects.prefetch_related("books__read_by")
+ lists = [
+ [[str(r) for r in b.read_by.all()] for b in a.books.all()] for a in qs
+ ]
+ self.assertEqual(
+ lists,
+ [
+ [["Amy"], ["Belinda"]], # Charlotte - Poems, Jane Eyre
+ [["Amy"]], # Anne - Poems
+ [["Amy"], []], # Emily - Poems, Wuthering Heights
+ [["Amy", "Belinda"]], # Jane - Sense and Sense
+ ],
+ )
+
+ def test_overriding_prefetch(self):
+ with self.assertNumQueries(3):
+ qs = Author.objects.prefetch_related("books", "books__read_by")
+ lists = [
+ [[str(r) for r in b.read_by.all()] for b in a.books.all()] for a in qs
+ ]
+ self.assertEqual(
+ lists,
+ [
+ [["Amy"], ["Belinda"]], # Charlotte - Poems, Jane Eyre
+ [["Amy"]], # Anne - Poems
+ [["Amy"], []], # Emily - Poems, Wuthering Heights
+ [["Amy", "Belinda"]], # Jane - Sense and Sense
+ ],
+ )
+ with self.assertNumQueries(3):
+ qs = Author.objects.prefetch_related("books__read_by", "books")
+ lists = [
+ [[str(r) for r in b.read_by.all()] for b in a.books.all()] for a in qs
+ ]
+ self.assertEqual(
+ lists,
+ [
+ [["Amy"], ["Belinda"]], # Charlotte - Poems, Jane Eyre
+ [["Amy"]], # Anne - Poems
+ [["Amy"], []], # Emily - Poems, Wuthering Heights
+ [["Amy", "Belinda"]], # Jane - Sense and Sense
+ ],
+ )
+
+ def test_get(self):
+ """
+ Objects retrieved with .get() get the prefetch behavior.
+ """
+ # Need a double
+ with self.assertNumQueries(3):
+ author = Author.objects.prefetch_related("books__read_by").get(
+ name="Charlotte"
+ )
+ lists = [[str(r) for r in b.read_by.all()] for b in author.books.all()]
+ self.assertEqual(lists, [["Amy"], ["Belinda"]]) # Poems, Jane Eyre
+
+ def test_foreign_key_then_m2m(self):
+ """
+ A m2m relation can be followed after a relation like ForeignKey that
+ doesn't have many objects.
+ """
+ with self.assertNumQueries(2):
+ qs = Author.objects.select_related("first_book").prefetch_related(
+ "first_book__read_by"
+ )
+ lists = [[str(r) for r in a.first_book.read_by.all()] for a in qs]
+ self.assertEqual(lists, [["Amy"], ["Amy"], ["Amy"], ["Amy", "Belinda"]])
+
+ def test_reverse_one_to_one_then_m2m(self):
+ """
+ A m2m relation can be followed after going through the select_related
+ reverse of an o2o.
+ """
+ qs = Author.objects.prefetch_related("bio__books").select_related("bio")
+
+ with self.assertNumQueries(1):
+ list(qs.all())
+
+ Bio.objects.create(author=self.author1)
+ with self.assertNumQueries(2):
+ list(qs.all())
+
+ def test_attribute_error(self):
+ qs = Reader.objects.prefetch_related("books_read__xyz")
+ msg = (
+ "Cannot find 'xyz' on Book object, 'books_read__xyz' "
+ "is an invalid parameter to prefetch_related()"
+ )
+ with self.assertRaisesMessage(AttributeError, msg) as cm:
+ list(qs)
+
+ self.assertIn("prefetch_related", str(cm.exception))
+
+ def test_invalid_final_lookup(self):
+ qs = Book.objects.prefetch_related("authors__name")
+ msg = (
+ "'authors__name' does not resolve to an item that supports "
+ "prefetching - this is an invalid parameter to prefetch_related()."
+ )
+ with self.assertRaisesMessage(ValueError, msg) as cm:
+ list(qs)
+
+ self.assertIn("prefetch_related", str(cm.exception))
+ self.assertIn("name", str(cm.exception))
+
+ def test_prefetch_eq(self):
+ prefetch_1 = Prefetch("authors", queryset=Author.objects.all())
+ prefetch_2 = Prefetch("books", queryset=Book.objects.all())
+ self.assertEqual(prefetch_1, prefetch_1)
+ self.assertEqual(prefetch_1, mock.ANY)
+ self.assertNotEqual(prefetch_1, prefetch_2)
+
+ def test_forward_m2m_to_attr_conflict(self):
+ msg = "to_attr=authors conflicts with a field on the Book model."
+ authors = Author.objects.all()
+ with self.assertRaisesMessage(ValueError, msg):
+ list(
+ Book.objects.prefetch_related(
+ Prefetch("authors", queryset=authors, to_attr="authors"),
+ )
+ )
+ # Without the ValueError, an author was deleted due to the implicit
+ # save of the relation assignment.
+ self.assertEqual(self.book1.authors.count(), 3)
+
+ def test_reverse_m2m_to_attr_conflict(self):
+ msg = "to_attr=books conflicts with a field on the Author model."
+ poems = Book.objects.filter(title="Poems")
+ with self.assertRaisesMessage(ValueError, msg):
+ list(
+ Author.objects.prefetch_related(
+ Prefetch("books", queryset=poems, to_attr="books"),
+ )
+ )
+ # Without the ValueError, a book was deleted due to the implicit
+ # save of reverse relation assignment.
+ self.assertEqual(self.author1.books.count(), 2)
+
+ def test_m2m_then_reverse_fk_object_ids(self):
+ with CaptureQueriesContext(connection) as queries:
+ list(Book.objects.prefetch_related("authors__addresses"))
+
+ sql = queries[-1]["sql"]
+ self.assertWhereContains(sql, self.author1.name)
+
+ def test_m2m_then_m2m_object_ids(self):
+ with CaptureQueriesContext(connection) as queries:
+ list(Book.objects.prefetch_related("authors__favorite_authors"))
+
+ sql = queries[-1]["sql"]
+ self.assertWhereContains(sql, self.author1.name)
+
+ def test_m2m_then_reverse_one_to_one_object_ids(self):
+ with CaptureQueriesContext(connection) as queries:
+ list(Book.objects.prefetch_related("authors__authorwithage"))
+
+ sql = queries[-1]["sql"]
+ self.assertWhereContains(sql, self.author1.id)
+
+ def test_filter_deferred(self):
+ """
+ Related filtering of prefetched querysets is deferred on m2m and
+ reverse m2o relations until necessary.
+ """
+ add_q = Query.add_q
+ for relation in ["authors", "first_time_authors"]:
+ with self.subTest(relation=relation):
+ with mock.patch.object(
+ Query,
+ "add_q",
+ autospec=True,
+ side_effect=lambda self, q: add_q(self, q),
+ ) as add_q_mock:
+ list(Book.objects.prefetch_related(relation))
+ self.assertEqual(add_q_mock.call_count, 1)
+
+ def test_named_values_list(self):
+ qs = Author.objects.prefetch_related("books")
+ self.assertCountEqual(
+ [value.name for value in qs.values_list("name", named=True)],
+ ["Anne", "Charlotte", "Emily", "Jane"],
+ )
+
+ def test_m2m_prefetching_iterator_with_chunks(self):
+ with self.assertNumQueries(3):
+ authors = [
+ b.authors.first()
+ for b in Book.objects.prefetch_related("authors").iterator(chunk_size=2)
+ ]
+ self.assertEqual(
+ authors,
+ [self.author1, self.author1, self.author3, self.author4],
+ )
+
+ def test_m2m_prefetching_iterator_without_chunks_error(self):
+ msg = (
+ "chunk_size must be provided when using QuerySet.iterator() after "
+ "prefetch_related()."
+ )
+ with self.assertRaisesMessage(ValueError, msg):
+ Book.objects.prefetch_related("authors").iterator()
+
+
+class RawQuerySetTests(TestDataMixin, TestCase):
+ def test_basic(self):
+ with self.assertNumQueries(2):
+ books = Book.objects.raw(
+ "SELECT * FROM prefetch_related_book WHERE id = %s", (self.book1.id,)
+ ).prefetch_related("authors")
+ book1 = list(books)[0]
+
+ with self.assertNumQueries(0):
+ self.assertCountEqual(
+ book1.authors.all(), [self.author1, self.author2, self.author3]
+ )
+
+ def test_prefetch_before_raw(self):
+ with self.assertNumQueries(2):
+ books = Book.objects.prefetch_related("authors").raw(
+ "SELECT * FROM prefetch_related_book WHERE id = %s", (self.book1.id,)
+ )
+ book1 = list(books)[0]
+
+ with self.assertNumQueries(0):
+ self.assertCountEqual(
+ book1.authors.all(), [self.author1, self.author2, self.author3]
+ )
+
+ def test_clear(self):
+ with self.assertNumQueries(5):
+ with_prefetch = Author.objects.raw(
+ "SELECT * FROM prefetch_related_author"
+ ).prefetch_related("books")
+ without_prefetch = with_prefetch.prefetch_related(None)
+ [list(a.books.all()) for a in without_prefetch]
+
+
+class CustomPrefetchTests(TestCase):
+ @classmethod
+ def traverse_qs(cls, obj_iter, path):
+ """
+ Helper method that returns a list containing a list of the objects in the
+ obj_iter. Then for each object in the obj_iter, the path will be
+ recursively travelled and the found objects are added to the return value.
+ """
+ ret_val = []
+
+ if hasattr(obj_iter, "all"):
+ obj_iter = obj_iter.all()
+
+ try:
+ iter(obj_iter)
+ except TypeError:
+ obj_iter = [obj_iter]
+
+ for obj in obj_iter:
+ rel_objs = []
+ for part in path:
+ if not part:
+ continue
+ try:
+ related = getattr(obj, part[0])
+ except ObjectDoesNotExist:
+ continue
+ if related is not None:
+ rel_objs.extend(cls.traverse_qs(related, [part[1:]]))
+ ret_val.append((obj, rel_objs))
+ return ret_val
+
+ @classmethod
+ def setUpTestData(cls):
+ cls.person1 = Person.objects.create(name="Joe")
+ cls.person2 = Person.objects.create(name="Mary")
+
+ # Set main_room for each house before creating the next one for
+ # databases where supports_nullable_unique_constraints is False.
+
+ cls.house1 = House.objects.create(
+ name="House 1", address="123 Main St", owner=cls.person1
+ )
+ cls.room1_1 = Room.objects.create(name="Dining room", house=cls.house1)
+ cls.room1_2 = Room.objects.create(name="Lounge", house=cls.house1)
+ cls.room1_3 = Room.objects.create(name="Kitchen", house=cls.house1)
+ cls.house1.main_room = cls.room1_1
+ cls.house1.save()
+ cls.person1.houses.add(cls.house1)
+
+ cls.house2 = House.objects.create(
+ name="House 2", address="45 Side St", owner=cls.person1
+ )
+ cls.room2_1 = Room.objects.create(name="Dining room", house=cls.house2)
+ cls.room2_2 = Room.objects.create(name="Lounge", house=cls.house2)
+ cls.room2_3 = Room.objects.create(name="Kitchen", house=cls.house2)
+ cls.house2.main_room = cls.room2_1
+ cls.house2.save()
+ cls.person1.houses.add(cls.house2)
+
+ cls.house3 = House.objects.create(
+ name="House 3", address="6 Downing St", owner=cls.person2
+ )
+ cls.room3_1 = Room.objects.create(name="Dining room", house=cls.house3)
+ cls.room3_2 = Room.objects.create(name="Lounge", house=cls.house3)
+ cls.room3_3 = Room.objects.create(name="Kitchen", house=cls.house3)
+ cls.house3.main_room = cls.room3_1
+ cls.house3.save()
+ cls.person2.houses.add(cls.house3)
+
+ cls.house4 = House.objects.create(
+ name="house 4", address="7 Regents St", owner=cls.person2
+ )
+ cls.room4_1 = Room.objects.create(name="Dining room", house=cls.house4)
+ cls.room4_2 = Room.objects.create(name="Lounge", house=cls.house4)
+ cls.room4_3 = Room.objects.create(name="Kitchen", house=cls.house4)
+ cls.house4.main_room = cls.room4_1
+ cls.house4.save()
+ cls.person2.houses.add(cls.house4)
+
+ def test_traverse_qs(self):
+ qs = Person.objects.prefetch_related("houses")
+ related_objs_normal = ([list(p.houses.all()) for p in qs],)
+ related_objs_from_traverse = [
+ [inner[0] for inner in o[1]] for o in self.traverse_qs(qs, [["houses"]])
+ ]
+ self.assertEqual(related_objs_normal, (related_objs_from_traverse,))
+
+ def test_ambiguous(self):
+ # Ambiguous: Lookup was already seen with a different queryset.
+ msg = (
+ "'houses' lookup was already seen with a different queryset. You "
+ "may need to adjust the ordering of your lookups."
+ )
+ # lookup.queryset shouldn't be evaluated.
+ with self.assertNumQueries(3):
+ with self.assertRaisesMessage(ValueError, msg):
+ self.traverse_qs(
+ Person.objects.prefetch_related(
+ "houses__rooms",
+ Prefetch("houses", queryset=House.objects.all()),
+ ),
+ [["houses", "rooms"]],
+ )
+
+ # Ambiguous: Lookup houses_lst doesn't yet exist when performing
+ # houses_lst__rooms.
+ msg = (
+ "Cannot find 'houses_lst' on Person object, 'houses_lst__rooms' is "
+ "an invalid parameter to prefetch_related()"
+ )
+ with self.assertRaisesMessage(AttributeError, msg):
+ self.traverse_qs(
+ Person.objects.prefetch_related(
+ "houses_lst__rooms",
+ Prefetch(
+ "houses", queryset=House.objects.all(), to_attr="houses_lst"
+ ),
+ ),
+ [["houses", "rooms"]],
+ )
+
+ # Not ambiguous.
+ self.traverse_qs(
+ Person.objects.prefetch_related("houses__rooms", "houses"),
+ [["houses", "rooms"]],
+ )
+
+ self.traverse_qs(
+ Person.objects.prefetch_related(
+ "houses__rooms",
+ Prefetch("houses", queryset=House.objects.all(), to_attr="houses_lst"),
+ ),
+ [["houses", "rooms"]],
+ )
+
+ def test_m2m(self):
+ # Control lookups.
+ with self.assertNumQueries(2):
+ lst1 = self.traverse_qs(
+ Person.objects.prefetch_related("houses"), [["houses"]]
+ )
+
+ # Test lookups.
+ with self.assertNumQueries(2):
+ lst2 = self.traverse_qs(
+ Person.objects.prefetch_related(Prefetch("houses")), [["houses"]]
+ )
+ self.assertEqual(lst1, lst2)
+ with self.assertNumQueries(2):
+ lst2 = self.traverse_qs(
+ Person.objects.prefetch_related(
+ Prefetch("houses", to_attr="houses_lst")
+ ),
+ [["houses_lst"]],
+ )
+ self.assertEqual(lst1, lst2)
+
+ def test_reverse_m2m(self):
+ # Control lookups.
+ with self.assertNumQueries(2):
+ lst1 = self.traverse_qs(
+ House.objects.prefetch_related("occupants"), [["occupants"]]
+ )
+
+ # Test lookups.
+ with self.assertNumQueries(2):
+ lst2 = self.traverse_qs(
+ House.objects.prefetch_related(Prefetch("occupants")), [["occupants"]]
+ )
+ self.assertEqual(lst1, lst2)
+ with self.assertNumQueries(2):
+ lst2 = self.traverse_qs(
+ House.objects.prefetch_related(
+ Prefetch("occupants", to_attr="occupants_lst")
+ ),
+ [["occupants_lst"]],
+ )
+ self.assertEqual(lst1, lst2)
+
+ def test_m2m_through_fk(self):
+ # Control lookups.
+ with self.assertNumQueries(3):
+ lst1 = self.traverse_qs(
+ Room.objects.prefetch_related("house__occupants"),
+ [["house", "occupants"]],
+ )
+
+ # Test lookups.
+ with self.assertNumQueries(3):
+ lst2 = self.traverse_qs(
+ Room.objects.prefetch_related(Prefetch("house__occupants")),
+ [["house", "occupants"]],
+ )
+ self.assertEqual(lst1, lst2)
+ with self.assertNumQueries(3):
+ lst2 = self.traverse_qs(
+ Room.objects.prefetch_related(
+ Prefetch("house__occupants", to_attr="occupants_lst")
+ ),
+ [["house", "occupants_lst"]],
+ )
+ self.assertEqual(lst1, lst2)
+
+ def test_m2m_through_gfk(self):
+ TaggedItem.objects.create(tag="houses", content_object=self.house1)
+ TaggedItem.objects.create(tag="houses", content_object=self.house2)
+
+ # Control lookups.
+ with self.assertNumQueries(3):
+ lst1 = self.traverse_qs(
+ TaggedItem.objects.filter(tag="houses").prefetch_related(
+ "content_object__rooms"
+ ),
+ [["content_object", "rooms"]],
+ )
+
+ # Test lookups.
+ with self.assertNumQueries(3):
+ lst2 = self.traverse_qs(
+ TaggedItem.objects.prefetch_related(
+ Prefetch("content_object"),
+ Prefetch("content_object__rooms", to_attr="rooms_lst"),
+ ),
+ [["content_object", "rooms_lst"]],
+ )
+ self.assertEqual(lst1, lst2)
+
+ def test_o2m_through_m2m(self):
+ # Control lookups.
+ with self.assertNumQueries(3):
+ lst1 = self.traverse_qs(
+ Person.objects.prefetch_related("houses", "houses__rooms"),
+ [["houses", "rooms"]],
+ )
+
+ # Test lookups.
+ with self.assertNumQueries(3):
+ lst2 = self.traverse_qs(
+ Person.objects.prefetch_related(Prefetch("houses"), "houses__rooms"),
+ [["houses", "rooms"]],
+ )
+ self.assertEqual(lst1, lst2)
+ with self.assertNumQueries(3):
+ lst2 = self.traverse_qs(
+ Person.objects.prefetch_related(
+ Prefetch("houses"), Prefetch("houses__rooms")
+ ),
+ [["houses", "rooms"]],
+ )
+ self.assertEqual(lst1, lst2)
+ with self.assertNumQueries(3):
+ lst2 = self.traverse_qs(
+ Person.objects.prefetch_related(
+ Prefetch("houses", to_attr="houses_lst"), "houses_lst__rooms"
+ ),
+ [["houses_lst", "rooms"]],
+ )
+ self.assertEqual(lst1, lst2)
+ with self.assertNumQueries(3):
+ lst2 = self.traverse_qs(
+ Person.objects.prefetch_related(
+ Prefetch("houses", to_attr="houses_lst"),
+ Prefetch("houses_lst__rooms", to_attr="rooms_lst"),
+ ),
+ [["houses_lst", "rooms_lst"]],
+ )
+ self.assertEqual(lst1, lst2)
+
+ def test_generic_rel(self):
+ bookmark = Bookmark.objects.create(url="http://www.djangoproject.com/")
+ TaggedItem.objects.create(content_object=bookmark, tag="django")
+ TaggedItem.objects.create(
+ content_object=bookmark, favorite=bookmark, tag="python"
+ )
+
+ # Control lookups.
+ with self.assertNumQueries(4):
+ lst1 = self.traverse_qs(
+ Bookmark.objects.prefetch_related(
+ "tags", "tags__content_object", "favorite_tags"
+ ),
+ [["tags", "content_object"], ["favorite_tags"]],
+ )
+
+ # Test lookups.
+ with self.assertNumQueries(4):
+ lst2 = self.traverse_qs(
+ Bookmark.objects.prefetch_related(
+ Prefetch("tags", to_attr="tags_lst"),
+ Prefetch("tags_lst__content_object"),
+ Prefetch("favorite_tags"),
+ ),
+ [["tags_lst", "content_object"], ["favorite_tags"]],
+ )
+ self.assertEqual(lst1, lst2)
+
+ def test_traverse_single_item_property(self):
+ # Control lookups.
+ with self.assertNumQueries(5):
+ lst1 = self.traverse_qs(
+ Person.objects.prefetch_related(
+ "houses__rooms",
+ "primary_house__occupants__houses",
+ ),
+ [["primary_house", "occupants", "houses"]],
+ )
+
+ # Test lookups.
+ with self.assertNumQueries(5):
+ lst2 = self.traverse_qs(
+ Person.objects.prefetch_related(
+ "houses__rooms",
+ Prefetch("primary_house__occupants", to_attr="occupants_lst"),
+ "primary_house__occupants_lst__houses",
+ ),
+ [["primary_house", "occupants_lst", "houses"]],
+ )
+ self.assertEqual(lst1, lst2)
+
+ def test_traverse_multiple_items_property(self):
+ # Control lookups.
+ with self.assertNumQueries(4):
+ lst1 = self.traverse_qs(
+ Person.objects.prefetch_related(
+ "houses",
+ "all_houses__occupants__houses",
+ ),
+ [["all_houses", "occupants", "houses"]],
+ )
+
+ # Test lookups.
+ with self.assertNumQueries(4):
+ lst2 = self.traverse_qs(
+ Person.objects.prefetch_related(
+ "houses",
+ Prefetch("all_houses__occupants", to_attr="occupants_lst"),
+ "all_houses__occupants_lst__houses",
+ ),
+ [["all_houses", "occupants_lst", "houses"]],
+ )
+ self.assertEqual(lst1, lst2)
+
+ def test_custom_qs(self):
+ # Test basic.
+ with self.assertNumQueries(2):
+ lst1 = list(Person.objects.prefetch_related("houses"))
+ with self.assertNumQueries(2):
+ lst2 = list(
+ Person.objects.prefetch_related(
+ Prefetch(
+ "houses", queryset=House.objects.all(), to_attr="houses_lst"
+ )
+ )
+ )
+ self.assertEqual(
+ self.traverse_qs(lst1, [["houses"]]),
+ self.traverse_qs(lst2, [["houses_lst"]]),
+ )
+
+ # Test queryset filtering.
+ with self.assertNumQueries(2):
+ lst2 = list(
+ Person.objects.prefetch_related(
+ Prefetch(
+ "houses",
+ queryset=House.objects.filter(
+ pk__in=[self.house1.pk, self.house3.pk]
+ ),
+ to_attr="houses_lst",
+ )
+ )
+ )
+ self.assertEqual(len(lst2[0].houses_lst), 1)
+ self.assertEqual(lst2[0].houses_lst[0], self.house1)
+ self.assertEqual(len(lst2[1].houses_lst), 1)
+ self.assertEqual(lst2[1].houses_lst[0], self.house3)
+
+ # Test flattened.
+ with self.assertNumQueries(3):
+ lst1 = list(Person.objects.prefetch_related("houses__rooms"))
+ with self.assertNumQueries(3):
+ lst2 = list(
+ Person.objects.prefetch_related(
+ Prefetch(
+ "houses__rooms",
+ queryset=Room.objects.all(),
+ to_attr="rooms_lst",
+ )
+ )
+ )
+ self.assertEqual(
+ self.traverse_qs(lst1, [["houses", "rooms"]]),
+ self.traverse_qs(lst2, [["houses", "rooms_lst"]]),
+ )
+
+ # Test inner select_related.
+ with self.assertNumQueries(3):
+ lst1 = list(Person.objects.prefetch_related("houses__owner"))
+ with self.assertNumQueries(2):
+ lst2 = list(
+ Person.objects.prefetch_related(
+ Prefetch("houses", queryset=House.objects.select_related("owner"))
+ )
+ )
+ self.assertEqual(
+ self.traverse_qs(lst1, [["houses", "owner"]]),
+ self.traverse_qs(lst2, [["houses", "owner"]]),
+ )
+
+ # Test inner prefetch.
+ inner_rooms_qs = Room.objects.filter(pk__in=[self.room1_1.pk, self.room1_2.pk])
+ houses_qs_prf = House.objects.prefetch_related(
+ Prefetch("rooms", queryset=inner_rooms_qs, to_attr="rooms_lst")
+ )
+ with self.assertNumQueries(4):
+ lst2 = list(
+ Person.objects.prefetch_related(
+ Prefetch(
+ "houses",
+ queryset=houses_qs_prf.filter(pk=self.house1.pk),
+ to_attr="houses_lst",
+ ),
+ Prefetch("houses_lst__rooms_lst__main_room_of"),
+ )
+ )
+
+ self.assertEqual(len(lst2[0].houses_lst[0].rooms_lst), 2)
+ self.assertEqual(lst2[0].houses_lst[0].rooms_lst[0], self.room1_1)
+ self.assertEqual(lst2[0].houses_lst[0].rooms_lst[1], self.room1_2)
+ self.assertEqual(lst2[0].houses_lst[0].rooms_lst[0].main_room_of, self.house1)
+ self.assertEqual(len(lst2[1].houses_lst), 0)
+
+ # Test ForwardManyToOneDescriptor.
+ houses = House.objects.select_related("owner")
+ with self.assertNumQueries(6):
+ rooms = Room.objects.prefetch_related("house")
+ lst1 = self.traverse_qs(rooms, [["house", "owner"]])
+ with self.assertNumQueries(2):
+ rooms = Room.objects.prefetch_related(Prefetch("house", queryset=houses))
+ lst2 = self.traverse_qs(rooms, [["house", "owner"]])
+ self.assertEqual(lst1, lst2)
+ with self.assertNumQueries(2):
+ houses = House.objects.select_related("owner")
+ rooms = Room.objects.prefetch_related(
+ Prefetch("house", queryset=houses, to_attr="house_attr")
+ )
+ lst2 = self.traverse_qs(rooms, [["house_attr", "owner"]])
+ self.assertEqual(lst1, lst2)
+ room = Room.objects.prefetch_related(
+ Prefetch("house", queryset=houses.filter(address="DoesNotExist"))
+ ).first()
+ with self.assertRaises(ObjectDoesNotExist):
+ getattr(room, "house")
+ room = Room.objects.prefetch_related(
+ Prefetch(
+ "house",
+ queryset=houses.filter(address="DoesNotExist"),
+ to_attr="house_attr",
+ )
+ ).first()
+ self.assertIsNone(room.house_attr)
+ rooms = Room.objects.prefetch_related(
+ Prefetch("house", queryset=House.objects.only("name"))
+ )
+ with self.assertNumQueries(2):
+ getattr(rooms.first().house, "name")
+ with self.assertNumQueries(3):
+ getattr(rooms.first().house, "address")
+
+ # Test ReverseOneToOneDescriptor.
+ houses = House.objects.select_related("owner")
+ with self.assertNumQueries(6):
+ rooms = Room.objects.prefetch_related("main_room_of")
+ lst1 = self.traverse_qs(rooms, [["main_room_of", "owner"]])
+ with self.assertNumQueries(2):
+ rooms = Room.objects.prefetch_related(
+ Prefetch("main_room_of", queryset=houses)
+ )
+ lst2 = self.traverse_qs(rooms, [["main_room_of", "owner"]])
+ self.assertEqual(lst1, lst2)
+ with self.assertNumQueries(2):
+ rooms = list(
+ Room.objects.prefetch_related(
+ Prefetch(
+ "main_room_of",
+ queryset=houses,
+ to_attr="main_room_of_attr",
+ )
+ )
+ )
+ lst2 = self.traverse_qs(rooms, [["main_room_of_attr", "owner"]])
+ self.assertEqual(lst1, lst2)
+ room = (
+ Room.objects.filter(main_room_of__isnull=False)
+ .prefetch_related(
+ Prefetch("main_room_of", queryset=houses.filter(address="DoesNotExist"))
+ )
+ .first()
+ )
+ with self.assertRaises(ObjectDoesNotExist):
+ getattr(room, "main_room_of")
+ room = (
+ Room.objects.filter(main_room_of__isnull=False)
+ .prefetch_related(
+ Prefetch(
+ "main_room_of",
+ queryset=houses.filter(address="DoesNotExist"),
+ to_attr="main_room_of_attr",
+ )
+ )
+ .first()
+ )
+ self.assertIsNone(room.main_room_of_attr)
+
+ # The custom queryset filters should be applied to the queryset
+ # instance returned by the manager.
+ person = Person.objects.prefetch_related(
+ Prefetch("houses", queryset=House.objects.filter(name="House 1")),
+ ).get(pk=self.person1.pk)
+ self.assertEqual(
+ list(person.houses.all()),
+ list(person.houses.all().all()),
+ )
+
+ def test_nested_prefetch_related_are_not_overwritten(self):
+ # Regression test for #24873
+ houses_2 = House.objects.prefetch_related(Prefetch("rooms"))
+ persons = Person.objects.prefetch_related(Prefetch("houses", queryset=houses_2))
+ houses = House.objects.prefetch_related(Prefetch("occupants", queryset=persons))
+ list(houses) # queryset must be evaluated once to reproduce the bug.
+ self.assertEqual(
+ houses.all()[0].occupants.all()[0].houses.all()[1].rooms.all()[0],
+ self.room2_1,
+ )
+
+ def test_nested_prefetch_related_with_duplicate_prefetcher(self):
+ """
+ Nested prefetches whose name clashes with descriptor names
+ (Person.houses here) are allowed.
+ """
+ occupants = Person.objects.prefetch_related(
+ Prefetch("houses", to_attr="some_attr_name"),
+ Prefetch("houses", queryset=House.objects.prefetch_related("main_room")),
+ )
+ houses = House.objects.prefetch_related(
+ Prefetch("occupants", queryset=occupants)
+ )
+ with self.assertNumQueries(5):
+ self.traverse_qs(list(houses), [["occupants", "houses", "main_room"]])
+
+ def test_values_queryset(self):
+ msg = "Prefetch querysets cannot use raw(), values(), and values_list()."
+ with self.assertRaisesMessage(ValueError, msg):
+ Prefetch("houses", House.objects.values("pk"))
+ with self.assertRaisesMessage(ValueError, msg):
+ Prefetch("houses", House.objects.values_list("pk"))
+ # That error doesn't affect managers with custom ModelIterable subclasses
+ self.assertIs(
+ Teacher.objects_custom.all()._iterable_class, ModelIterableSubclass
+ )
+ Prefetch("teachers", Teacher.objects_custom.all())
+
+ def test_raw_queryset(self):
+ msg = "Prefetch querysets cannot use raw(), values(), and values_list()."
+ with self.assertRaisesMessage(ValueError, msg):
+ Prefetch("houses", House.objects.raw("select pk from house"))
+
+ def test_to_attr_doesnt_cache_through_attr_as_list(self):
+ house = House.objects.prefetch_related(
+ Prefetch("rooms", queryset=Room.objects.all(), to_attr="to_rooms"),
+ ).get(pk=self.house3.pk)
+ self.assertIsInstance(house.rooms.all(), QuerySet)
+
+ def test_to_attr_cached_property(self):
+ persons = Person.objects.prefetch_related(
+ Prefetch("houses", House.objects.all(), to_attr="cached_all_houses"),
+ )
+ for person in persons:
+ # To bypass caching at the related descriptor level, don't use
+ # person.houses.all() here.
+ all_houses = list(House.objects.filter(occupants=person))
+ with self.assertNumQueries(0):
+ self.assertEqual(person.cached_all_houses, all_houses)
+
+ def test_filter_deferred(self):
+ """
+ Related filtering of prefetched querysets is deferred until necessary.
+ """
+ add_q = Query.add_q
+ with mock.patch.object(
+ Query,
+ "add_q",
+ autospec=True,
+ side_effect=lambda self, q: add_q(self, q),
+ ) as add_q_mock:
+ list(
+ House.objects.prefetch_related(
+ Prefetch("occupants", queryset=Person.objects.all())
+ )
+ )
+ self.assertEqual(add_q_mock.call_count, 1)
+
+
+class DefaultManagerTests(TestCase):
+ @classmethod
+ def setUpTestData(cls):
+ cls.qual1 = Qualification.objects.create(name="BA")
+ cls.qual2 = Qualification.objects.create(name="BSci")
+ cls.qual3 = Qualification.objects.create(name="MA")
+ cls.qual4 = Qualification.objects.create(name="PhD")
+
+ cls.teacher1 = Teacher.objects.create(name="Mr Cleese")
+ cls.teacher2 = Teacher.objects.create(name="Mr Idle")
+ cls.teacher3 = Teacher.objects.create(name="Mr Chapman")
+ cls.teacher1.qualifications.add(cls.qual1, cls.qual2, cls.qual3, cls.qual4)
+ cls.teacher2.qualifications.add(cls.qual1)
+ cls.teacher3.qualifications.add(cls.qual2)
+
+ cls.dept1 = Department.objects.create(name="English")
+ cls.dept2 = Department.objects.create(name="Physics")
+ cls.dept1.teachers.add(cls.teacher1, cls.teacher2)
+ cls.dept2.teachers.add(cls.teacher1, cls.teacher3)
+
+ def test_m2m_then_m2m(self):
+ with self.assertNumQueries(3):
+ # When we prefetch the teachers, and force the query, we don't want
+ # the default manager on teachers to immediately get all the related
+ # qualifications, since this will do one query per teacher.
+ qs = Department.objects.prefetch_related("teachers")
+ depts = "".join(
+ "%s department: %s\n"
+ % (dept.name, ", ".join(str(t) for t in dept.teachers.all()))
+ for dept in qs
+ )
+
+ self.assertEqual(
+ depts,
+ "English department: Mr Cleese (BA, BSci, MA, PhD), Mr Idle (BA)\n"
+ "Physics department: Mr Cleese (BA, BSci, MA, PhD), Mr Chapman "
+ "(BSci)\n",
+ )
+
+
+class GenericRelationTests(TestCase):
+ @classmethod
+ def setUpTestData(cls):
+ book1 = Book.objects.create(title="Winnie the Pooh")
+ book2 = Book.objects.create(title="Do you like green eggs and spam?")
+ book3 = Book.objects.create(title="Three Men In A Boat")
+
+ reader1 = Reader.objects.create(name="me")
+ reader2 = Reader.objects.create(name="you")
+ reader3 = Reader.objects.create(name="someone")
+
+ book1.read_by.add(reader1, reader2)
+ book2.read_by.add(reader2)
+ book3.read_by.add(reader3)
+
+ cls.book1, cls.book2, cls.book3 = book1, book2, book3
+ cls.reader1, cls.reader2, cls.reader3 = reader1, reader2, reader3
+
+ def test_prefetch_GFK(self):
+ TaggedItem.objects.create(tag="awesome", content_object=self.book1)
+ TaggedItem.objects.create(tag="great", content_object=self.reader1)
+ TaggedItem.objects.create(tag="outstanding", content_object=self.book2)
+ TaggedItem.objects.create(tag="amazing", content_object=self.reader3)
+
+ # 1 for TaggedItem table, 1 for Book table, 1 for Reader table
+ with self.assertNumQueries(3):
+ qs = TaggedItem.objects.prefetch_related("content_object")
+ list(qs)
+
+ def test_prefetch_GFK_nonint_pk(self):
+ Comment.objects.create(comment="awesome", content_object=self.book1)
+
+ # 1 for Comment table, 1 for Book table
+ with self.assertNumQueries(2):
+ qs = Comment.objects.prefetch_related("content_object")
+ [c.content_object for c in qs]
+
+ def test_prefetch_GFK_uuid_pk(self):
+ article = Article.objects.create(name="Django")
+ Comment.objects.create(comment="awesome", content_object_uuid=article)
+ qs = Comment.objects.prefetch_related("content_object_uuid")
+ self.assertEqual([c.content_object_uuid for c in qs], [article])
+
+ def test_prefetch_GFK_fk_pk(self):
+ book = Book.objects.create(title="Poems")
+ book_with_year = BookWithYear.objects.create(book=book, published_year=2019)
+ Comment.objects.create(comment="awesome", content_object=book_with_year)
+ qs = Comment.objects.prefetch_related("content_object")
+ self.assertEqual([c.content_object for c in qs], [book_with_year])
+
+ def test_traverse_GFK(self):
+ """
+ A 'content_object' can be traversed with prefetch_related() and
+ get to related objects on the other side (assuming it is suitably
+ filtered)
+ """
+ TaggedItem.objects.create(tag="awesome", content_object=self.book1)
+ TaggedItem.objects.create(tag="awesome", content_object=self.book2)
+ TaggedItem.objects.create(tag="awesome", content_object=self.book3)
+ TaggedItem.objects.create(tag="awesome", content_object=self.reader1)
+ TaggedItem.objects.create(tag="awesome", content_object=self.reader2)
+
+ ct = ContentType.objects.get_for_model(Book)
+
+ # We get 3 queries - 1 for main query, 1 for content_objects since they
+ # all use the same table, and 1 for the 'read_by' relation.
+ with self.assertNumQueries(3):
+ # If we limit to books, we know that they will have 'read_by'
+ # attributes, so the following makes sense:
+ qs = TaggedItem.objects.filter(
+ content_type=ct, tag="awesome"
+ ).prefetch_related("content_object__read_by")
+ readers_of_awesome_books = {
+ r.name for tag in qs for r in tag.content_object.read_by.all()
+ }
+ self.assertEqual(readers_of_awesome_books, {"me", "you", "someone"})
+
+ def test_nullable_GFK(self):
+ TaggedItem.objects.create(
+ tag="awesome", content_object=self.book1, created_by=self.reader1
+ )
+ TaggedItem.objects.create(tag="great", content_object=self.book2)
+ TaggedItem.objects.create(tag="rubbish", content_object=self.book3)
+
+ with self.assertNumQueries(2):
+ result = [
+ t.created_by for t in TaggedItem.objects.prefetch_related("created_by")
+ ]
+
+ self.assertEqual(result, [t.created_by for t in TaggedItem.objects.all()])
+
+ def test_generic_relation(self):
+ bookmark = Bookmark.objects.create(url="http://www.djangoproject.com/")
+ TaggedItem.objects.create(content_object=bookmark, tag="django")
+ TaggedItem.objects.create(content_object=bookmark, tag="python")
+
+ with self.assertNumQueries(2):
+ tags = [
+ t.tag
+ for b in Bookmark.objects.prefetch_related("tags")
+ for t in b.tags.all()
+ ]
+ self.assertEqual(sorted(tags), ["django", "python"])
+
+ def test_charfield_GFK(self):
+ b = Bookmark.objects.create(url="http://www.djangoproject.com/")
+ TaggedItem.objects.create(content_object=b, tag="django")
+ TaggedItem.objects.create(content_object=b, favorite=b, tag="python")
+
+ with self.assertNumQueries(3):
+ bookmark = Bookmark.objects.filter(pk=b.pk).prefetch_related(
+ "tags", "favorite_tags"
+ )[0]
+ self.assertEqual(
+ sorted(i.tag for i in bookmark.tags.all()), ["django", "python"]
+ )
+ self.assertEqual([i.tag for i in bookmark.favorite_tags.all()], ["python"])
+
+ def test_custom_queryset(self):
+ bookmark = Bookmark.objects.create(url="http://www.djangoproject.com/")
+ django_tag = TaggedItem.objects.create(content_object=bookmark, tag="django")
+ TaggedItem.objects.create(content_object=bookmark, tag="python")
+
+ with self.assertNumQueries(2):
+ bookmark = Bookmark.objects.prefetch_related(
+ Prefetch("tags", TaggedItem.objects.filter(tag="django")),
+ ).get()
+
+ with self.assertNumQueries(0):
+ self.assertEqual(list(bookmark.tags.all()), [django_tag])
+
+ # The custom queryset filters should be applied to the queryset
+ # instance returned by the manager.
+ self.assertEqual(list(bookmark.tags.all()), list(bookmark.tags.all().all()))
+
+ def test_deleted_GFK(self):
+ TaggedItem.objects.create(tag="awesome", content_object=self.book1)
+ TaggedItem.objects.create(tag="awesome", content_object=self.book2)
+ ct = ContentType.objects.get_for_model(Book)
+
+ book1_pk = self.book1.pk
+ self.book1.delete()
+
+ with self.assertNumQueries(2):
+ qs = TaggedItem.objects.filter(tag="awesome").prefetch_related(
+ "content_object"
+ )
+ result = [
+ (tag.object_id, tag.content_type_id, tag.content_object) for tag in qs
+ ]
+ self.assertEqual(
+ result,
+ [
+ (book1_pk, ct.pk, None),
+ (self.book2.pk, ct.pk, self.book2),
+ ],
+ )
+
+
+class MultiTableInheritanceTest(TestCase):
+ @classmethod
+ def setUpTestData(cls):
+ cls.book1 = BookWithYear.objects.create(title="Poems", published_year=2010)
+ cls.book2 = BookWithYear.objects.create(title="More poems", published_year=2011)
+ cls.author1 = AuthorWithAge.objects.create(
+ name="Jane", first_book=cls.book1, age=50
+ )
+ cls.author2 = AuthorWithAge.objects.create(
+ name="Tom", first_book=cls.book1, age=49
+ )
+ cls.author3 = AuthorWithAge.objects.create(
+ name="Robert", first_book=cls.book2, age=48
+ )
+ cls.author_address = AuthorAddress.objects.create(
+ author=cls.author1, address="SomeStreet 1"
+ )
+ cls.book2.aged_authors.add(cls.author2, cls.author3)
+ cls.br1 = BookReview.objects.create(book=cls.book1, notes="review book1")
+ cls.br2 = BookReview.objects.create(book=cls.book2, notes="review book2")
+
+ def test_foreignkey(self):
+ with self.assertNumQueries(2):
+ qs = AuthorWithAge.objects.prefetch_related("addresses")
+ addresses = [
+ [str(address) for address in obj.addresses.all()] for obj in qs
+ ]
+ self.assertEqual(addresses, [[str(self.author_address)], [], []])
+
+ def test_foreignkey_to_inherited(self):
+ with self.assertNumQueries(2):
+ qs = BookReview.objects.prefetch_related("book")
+ titles = [obj.book.title for obj in qs]
+ self.assertCountEqual(titles, ["Poems", "More poems"])
+
+ def test_m2m_to_inheriting_model(self):
+ qs = AuthorWithAge.objects.prefetch_related("books_with_year")
+ with self.assertNumQueries(2):
+ lst = [
+ [str(book) for book in author.books_with_year.all()] for author in qs
+ ]
+ qs = AuthorWithAge.objects.all()
+ lst2 = [[str(book) for book in author.books_with_year.all()] for author in qs]
+ self.assertEqual(lst, lst2)
+
+ qs = BookWithYear.objects.prefetch_related("aged_authors")
+ with self.assertNumQueries(2):
+ lst = [[str(author) for author in book.aged_authors.all()] for book in qs]
+ qs = BookWithYear.objects.all()
+ lst2 = [[str(author) for author in book.aged_authors.all()] for book in qs]
+ self.assertEqual(lst, lst2)
+
+ def test_parent_link_prefetch(self):
+ with self.assertNumQueries(2):
+ [a.author for a in AuthorWithAge.objects.prefetch_related("author")]
+
+ @override_settings(DEBUG=True)
+ def test_child_link_prefetch(self):
+ with self.assertNumQueries(2):
+ authors = [
+ a.authorwithage
+ for a in Author.objects.prefetch_related("authorwithage")
+ ]
+
+ # Regression for #18090: the prefetching query must include an IN clause.
+ # Note that on Oracle the table name is upper case in the generated SQL,
+ # thus the .lower() call.
+ self.assertIn("authorwithage", connection.queries[-1]["sql"].lower())
+ self.assertIn(" IN ", connection.queries[-1]["sql"])
+
+ self.assertEqual(authors, [a.authorwithage for a in Author.objects.all()])
+
+
+class ForeignKeyToFieldTest(TestCase):
+ @classmethod
+ def setUpTestData(cls):
+ cls.book = Book.objects.create(title="Poems")
+ cls.author1 = Author.objects.create(name="Jane", first_book=cls.book)
+ cls.author2 = Author.objects.create(name="Tom", first_book=cls.book)
+ cls.author3 = Author.objects.create(name="Robert", first_book=cls.book)
+ cls.author_address = AuthorAddress.objects.create(
+ author=cls.author1, address="SomeStreet 1"
+ )
+ FavoriteAuthors.objects.create(author=cls.author1, likes_author=cls.author2)
+ FavoriteAuthors.objects.create(author=cls.author2, likes_author=cls.author3)
+ FavoriteAuthors.objects.create(author=cls.author3, likes_author=cls.author1)
+
+ def test_foreignkey(self):
+ with self.assertNumQueries(2):
+ qs = Author.objects.prefetch_related("addresses")
+ addresses = [
+ [str(address) for address in obj.addresses.all()] for obj in qs
+ ]
+ self.assertEqual(addresses, [[str(self.author_address)], [], []])
+
+ def test_m2m(self):
+ with self.assertNumQueries(3):
+ qs = Author.objects.prefetch_related("favorite_authors", "favors_me")
+ favorites = [
+ (
+ [str(i_like) for i_like in author.favorite_authors.all()],
+ [str(likes_me) for likes_me in author.favors_me.all()],
+ )
+ for author in qs
+ ]
+ self.assertEqual(
+ favorites,
+ [
+ ([str(self.author2)], [str(self.author3)]),
+ ([str(self.author3)], [str(self.author1)]),
+ ([str(self.author1)], [str(self.author2)]),
+ ],
+ )
+
+
+class LookupOrderingTest(TestCase):
+ """
+ Test cases that demonstrate that ordering of lookups is important, and
+ ensure it is preserved.
+ """
+
+ @classmethod
+ def setUpTestData(cls):
+ person1 = Person.objects.create(name="Joe")
+ person2 = Person.objects.create(name="Mary")
+
+ # Set main_room for each house before creating the next one for
+ # databases where supports_nullable_unique_constraints is False.
+ house1 = House.objects.create(address="123 Main St")
+ room1_1 = Room.objects.create(name="Dining room", house=house1)
+ Room.objects.create(name="Lounge", house=house1)
+ Room.objects.create(name="Kitchen", house=house1)
+ house1.main_room = room1_1
+ house1.save()
+ person1.houses.add(house1)
+
+ house2 = House.objects.create(address="45 Side St")
+ room2_1 = Room.objects.create(name="Dining room", house=house2)
+ Room.objects.create(name="Lounge", house=house2)
+ house2.main_room = room2_1
+ house2.save()
+ person1.houses.add(house2)
+
+ house3 = House.objects.create(address="6 Downing St")
+ room3_1 = Room.objects.create(name="Dining room", house=house3)
+ Room.objects.create(name="Lounge", house=house3)
+ Room.objects.create(name="Kitchen", house=house3)
+ house3.main_room = room3_1
+ house3.save()
+ person2.houses.add(house3)
+
+ house4 = House.objects.create(address="7 Regents St")
+ room4_1 = Room.objects.create(name="Dining room", house=house4)
+ Room.objects.create(name="Lounge", house=house4)
+ house4.main_room = room4_1
+ house4.save()
+ person2.houses.add(house4)
+
+ def test_order(self):
+ with self.assertNumQueries(4):
+ # The following two queries must be done in the same order as written,
+ # otherwise 'primary_house' will cause non-prefetched lookups
+ qs = Person.objects.prefetch_related(
+ "houses__rooms", "primary_house__occupants"
+ )
+ [list(p.primary_house.occupants.all()) for p in qs]
+
+
+class NullableTest(TestCase):
+ @classmethod
+ def setUpTestData(cls):
+ boss = Employee.objects.create(name="Peter")
+ Employee.objects.create(name="Joe", boss=boss)
+ Employee.objects.create(name="Angela", boss=boss)
+
+ def test_traverse_nullable(self):
+ # Because we use select_related() for 'boss', it doesn't need to be
+ # prefetched, but we can still traverse it although it contains some nulls
+ with self.assertNumQueries(2):
+ qs = Employee.objects.select_related("boss").prefetch_related("boss__serfs")
+ co_serfs = [
+ list(e.boss.serfs.all()) if e.boss is not None else [] for e in qs
+ ]
+
+ qs2 = Employee.objects.select_related("boss")
+ co_serfs2 = [
+ list(e.boss.serfs.all()) if e.boss is not None else [] for e in qs2
+ ]
+
+ self.assertEqual(co_serfs, co_serfs2)
+
+ def test_prefetch_nullable(self):
+ # One for main employee, one for boss, one for serfs
+ with self.assertNumQueries(3):
+ qs = Employee.objects.prefetch_related("boss__serfs")
+ co_serfs = [
+ list(e.boss.serfs.all()) if e.boss is not None else [] for e in qs
+ ]
+
+ qs2 = Employee.objects.all()
+ co_serfs2 = [
+ list(e.boss.serfs.all()) if e.boss is not None else [] for e in qs2
+ ]
+
+ self.assertEqual(co_serfs, co_serfs2)
+
+ def test_in_bulk(self):
+ """
+ In-bulk does correctly prefetch objects by not using .iterator()
+ directly.
+ """
+ boss1 = Employee.objects.create(name="Peter")
+ boss2 = Employee.objects.create(name="Jack")
+ with self.assertNumQueries(2):
+ # Prefetch is done and it does not cause any errors.
+ bulk = Employee.objects.prefetch_related("serfs").in_bulk(
+ [boss1.pk, boss2.pk]
+ )
+ for b in bulk.values():
+ list(b.serfs.all())
+
+
+class MultiDbTests(TestCase):
+ databases = {"default", "other"}
+
+ def test_using_is_honored_m2m(self):
+ B = Book.objects.using("other")
+ A = Author.objects.using("other")
+ book1 = B.create(title="Poems")
+ book2 = B.create(title="Jane Eyre")
+ book3 = B.create(title="Wuthering Heights")
+ book4 = B.create(title="Sense and Sensibility")
+
+ author1 = A.create(name="Charlotte", first_book=book1)
+ author2 = A.create(name="Anne", first_book=book1)
+ author3 = A.create(name="Emily", first_book=book1)
+ author4 = A.create(name="Jane", first_book=book4)
+
+ book1.authors.add(author1, author2, author3)
+ book2.authors.add(author1)
+ book3.authors.add(author3)
+ book4.authors.add(author4)
+
+ # Forward
+ qs1 = B.prefetch_related("authors")
+ with self.assertNumQueries(2, using="other"):
+ books = "".join(
+ "%s (%s)\n"
+ % (book.title, ", ".join(a.name for a in book.authors.all()))
+ for book in qs1
+ )
+ self.assertEqual(
+ books,
+ "Poems (Charlotte, Anne, Emily)\n"
+ "Jane Eyre (Charlotte)\n"
+ "Wuthering Heights (Emily)\n"
+ "Sense and Sensibility (Jane)\n",
+ )
+
+ # Reverse
+ qs2 = A.prefetch_related("books")
+ with self.assertNumQueries(2, using="other"):
+ authors = "".join(
+ "%s: %s\n"
+ % (author.name, ", ".join(b.title for b in author.books.all()))
+ for author in qs2
+ )
+ self.assertEqual(
+ authors,
+ "Charlotte: Poems, Jane Eyre\n"
+ "Anne: Poems\n"
+ "Emily: Poems, Wuthering Heights\n"
+ "Jane: Sense and Sensibility\n",
+ )
+
+ def test_using_is_honored_fkey(self):
+ B = Book.objects.using("other")
+ A = Author.objects.using("other")
+ book1 = B.create(title="Poems")
+ book2 = B.create(title="Sense and Sensibility")
+
+ A.create(name="Charlotte Bronte", first_book=book1)
+ A.create(name="Jane Austen", first_book=book2)
+
+ # Forward
+ with self.assertNumQueries(2, using="other"):
+ books = ", ".join(
+ a.first_book.title for a in A.prefetch_related("first_book")
+ )
+ self.assertEqual("Poems, Sense and Sensibility", books)
+
+ # Reverse
+ with self.assertNumQueries(2, using="other"):
+ books = "".join(
+ "%s (%s)\n"
+ % (b.title, ", ".join(a.name for a in b.first_time_authors.all()))
+ for b in B.prefetch_related("first_time_authors")
+ )
+ self.assertEqual(
+ books,
+ "Poems (Charlotte Bronte)\nSense and Sensibility (Jane Austen)\n",
+ )
+
+ def test_using_is_honored_inheritance(self):
+ B = BookWithYear.objects.using("other")
+ A = AuthorWithAge.objects.using("other")
+ book1 = B.create(title="Poems", published_year=2010)
+ B.create(title="More poems", published_year=2011)
+ A.create(name="Jane", first_book=book1, age=50)
+ A.create(name="Tom", first_book=book1, age=49)
+
+ # parent link
+ with self.assertNumQueries(2, using="other"):
+ authors = ", ".join(a.author.name for a in A.prefetch_related("author"))
+
+ self.assertEqual(authors, "Jane, Tom")
+
+ # child link
+ with self.assertNumQueries(2, using="other"):
+ ages = ", ".join(
+ str(a.authorwithage.age) for a in A.prefetch_related("authorwithage")
+ )
+
+ self.assertEqual(ages, "50, 49")
+
+ def test_using_is_honored_custom_qs(self):
+ B = Book.objects.using("other")
+ A = Author.objects.using("other")
+ book1 = B.create(title="Poems")
+ book2 = B.create(title="Sense and Sensibility")
+
+ A.create(name="Charlotte Bronte", first_book=book1)
+ A.create(name="Jane Austen", first_book=book2)
+
+ # Implicit hinting
+ with self.assertNumQueries(2, using="other"):
+ prefetch = Prefetch("first_time_authors", queryset=Author.objects.all())
+ books = "".join(
+ "%s (%s)\n"
+ % (b.title, ", ".join(a.name for a in b.first_time_authors.all()))
+ for b in B.prefetch_related(prefetch)
+ )
+ self.assertEqual(
+ books,
+ "Poems (Charlotte Bronte)\nSense and Sensibility (Jane Austen)\n",
+ )
+ # Explicit using on the same db.
+ with self.assertNumQueries(2, using="other"):
+ prefetch = Prefetch(
+ "first_time_authors", queryset=Author.objects.using("other")
+ )
+ books = "".join(
+ "%s (%s)\n"
+ % (b.title, ", ".join(a.name for a in b.first_time_authors.all()))
+ for b in B.prefetch_related(prefetch)
+ )
+ self.assertEqual(
+ books,
+ "Poems (Charlotte Bronte)\nSense and Sensibility (Jane Austen)\n",
+ )
+
+ # Explicit using on a different db.
+ with self.assertNumQueries(1, using="default"), self.assertNumQueries(
+ 1, using="other"
+ ):
+ prefetch = Prefetch(
+ "first_time_authors", queryset=Author.objects.using("default")
+ )
+ books = "".join(
+ "%s (%s)\n"
+ % (b.title, ", ".join(a.name for a in b.first_time_authors.all()))
+ for b in B.prefetch_related(prefetch)
+ )
+ self.assertEqual(books, "Poems ()\n" "Sense and Sensibility ()\n")
+
+
+class Ticket19607Tests(TestCase):
+ @classmethod
+ def setUpTestData(cls):
+ LessonEntry.objects.bulk_create(
+ LessonEntry(id=id_, name1=name1, name2=name2)
+ for id_, name1, name2 in [
+ (1, "einfach", "simple"),
+ (2, "schwierig", "difficult"),
+ ]
+ )
+ WordEntry.objects.bulk_create(
+ WordEntry(id=id_, lesson_entry_id=lesson_entry_id, name=name)
+ for id_, lesson_entry_id, name in [
+ (1, 1, "einfach"),
+ (2, 1, "simple"),
+ (3, 2, "schwierig"),
+ (4, 2, "difficult"),
+ ]
+ )
+
+ def test_bug(self):
+ list(
+ WordEntry.objects.prefetch_related(
+ "lesson_entry", "lesson_entry__wordentry_set"
+ )
+ )
+
+
+class Ticket21410Tests(TestCase):
+ @classmethod
+ def setUpTestData(cls):
+ book1 = Book.objects.create(title="Poems")
+ book2 = Book.objects.create(title="Jane Eyre")
+ book3 = Book.objects.create(title="Wuthering Heights")
+ book4 = Book.objects.create(title="Sense and Sensibility")
+
+ author1 = Author2.objects.create(name="Charlotte", first_book=book1)
+ author2 = Author2.objects.create(name="Anne", first_book=book1)
+ author3 = Author2.objects.create(name="Emily", first_book=book1)
+ author4 = Author2.objects.create(name="Jane", first_book=book4)
+
+ author1.favorite_books.add(book1, book2, book3)
+ author2.favorite_books.add(book1)
+ author3.favorite_books.add(book2)
+ author4.favorite_books.add(book3)
+
+ def test_bug(self):
+ list(Author2.objects.prefetch_related("first_book", "favorite_books"))
+
+
+class Ticket21760Tests(TestCase):
+ @classmethod
+ def setUpTestData(cls):
+ cls.rooms = []
+ for _ in range(3):
+ house = House.objects.create()
+ for _ in range(3):
+ cls.rooms.append(Room.objects.create(house=house))
+ # Set main_room for each house before creating the next one for
+ # databases where supports_nullable_unique_constraints is False.
+ house.main_room = cls.rooms[-3]
+ house.save()
+
+ def test_bug(self):
+ prefetcher = get_prefetcher(self.rooms[0], "house", "house")[0]
+ queryset = prefetcher.get_prefetch_queryset(list(Room.objects.all()))[0]
+ self.assertNotIn(" JOIN ", str(queryset.query))
+
+
+class DirectPrefetchedObjectCacheReuseTests(TestCase):
+ """
+ prefetch_related() reuses objects fetched in _prefetched_objects_cache.
+
+ When objects are prefetched and not stored as an instance attribute (often
+ intermediary relationships), they are saved to the
+ _prefetched_objects_cache attribute. prefetch_related() takes
+ _prefetched_objects_cache into account when determining whether an object
+ has been fetched[1] and retrieves results from it when it is populated [2].
+
+ [1]: #25546 (duplicate queries on nested Prefetch)
+ [2]: #27554 (queryset evaluation fails with a mix of nested and flattened
+ prefetches)
+ """
+
+ @classmethod
+ def setUpTestData(cls):
+ cls.book1, cls.book2 = [
+ Book.objects.create(title="book1"),
+ Book.objects.create(title="book2"),
+ ]
+ cls.author11, cls.author12, cls.author21 = [
+ Author.objects.create(first_book=cls.book1, name="Author11"),
+ Author.objects.create(first_book=cls.book1, name="Author12"),
+ Author.objects.create(first_book=cls.book2, name="Author21"),
+ ]
+ cls.author1_address1, cls.author1_address2, cls.author2_address1 = [
+ AuthorAddress.objects.create(author=cls.author11, address="Happy place"),
+ AuthorAddress.objects.create(author=cls.author12, address="Haunted house"),
+ AuthorAddress.objects.create(author=cls.author21, address="Happy place"),
+ ]
+ cls.bookwithyear1 = BookWithYear.objects.create(
+ title="Poems", published_year=2010
+ )
+ cls.bookreview1 = BookReview.objects.create(book=cls.bookwithyear1)
+
+ def test_detect_is_fetched(self):
+ """
+ Nested prefetch_related() shouldn't trigger duplicate queries for the same
+ lookup.
+ """
+ with self.assertNumQueries(3):
+ books = Book.objects.filter(title__in=["book1", "book2"]).prefetch_related(
+ Prefetch(
+ "first_time_authors",
+ Author.objects.prefetch_related(
+ Prefetch(
+ "addresses",
+ AuthorAddress.objects.filter(address="Happy place"),
+ )
+ ),
+ ),
+ )
+ book1, book2 = list(books)
+
+ with self.assertNumQueries(0):
+ self.assertSequenceEqual(
+ book1.first_time_authors.all(), [self.author11, self.author12]
+ )
+ self.assertSequenceEqual(book2.first_time_authors.all(), [self.author21])
+
+ self.assertSequenceEqual(
+ book1.first_time_authors.all()[0].addresses.all(),
+ [self.author1_address1],
+ )
+ self.assertSequenceEqual(
+ book1.first_time_authors.all()[1].addresses.all(), []
+ )
+ self.assertSequenceEqual(
+ book2.first_time_authors.all()[0].addresses.all(),
+ [self.author2_address1],
+ )
+
+ self.assertEqual(
+ list(book1.first_time_authors.all()),
+ list(book1.first_time_authors.all().all()),
+ )
+ self.assertEqual(
+ list(book2.first_time_authors.all()),
+ list(book2.first_time_authors.all().all()),
+ )
+ self.assertEqual(
+ list(book1.first_time_authors.all()[0].addresses.all()),
+ list(book1.first_time_authors.all()[0].addresses.all().all()),
+ )
+ self.assertEqual(
+ list(book1.first_time_authors.all()[1].addresses.all()),
+ list(book1.first_time_authors.all()[1].addresses.all().all()),
+ )
+ self.assertEqual(
+ list(book2.first_time_authors.all()[0].addresses.all()),
+ list(book2.first_time_authors.all()[0].addresses.all().all()),
+ )
+
+ def test_detect_is_fetched_with_to_attr(self):
+ with self.assertNumQueries(3):
+ books = Book.objects.filter(title__in=["book1", "book2"]).prefetch_related(
+ Prefetch(
+ "first_time_authors",
+ Author.objects.prefetch_related(
+ Prefetch(
+ "addresses",
+ AuthorAddress.objects.filter(address="Happy place"),
+ to_attr="happy_place",
+ )
+ ),
+ to_attr="first_authors",
+ ),
+ )
+ book1, book2 = list(books)
+
+ with self.assertNumQueries(0):
+ self.assertEqual(book1.first_authors, [self.author11, self.author12])
+ self.assertEqual(book2.first_authors, [self.author21])
+
+ self.assertEqual(
+ book1.first_authors[0].happy_place, [self.author1_address1]
+ )
+ self.assertEqual(book1.first_authors[1].happy_place, [])
+ self.assertEqual(
+ book2.first_authors[0].happy_place, [self.author2_address1]
+ )
+
+ def test_prefetch_reverse_foreign_key(self):
+ with self.assertNumQueries(2):
+ (bookwithyear1,) = BookWithYear.objects.prefetch_related("bookreview_set")
+ with self.assertNumQueries(0):
+ self.assertCountEqual(
+ bookwithyear1.bookreview_set.all(), [self.bookreview1]
+ )
+ with self.assertNumQueries(0):
+ prefetch_related_objects([bookwithyear1], "bookreview_set")
+
+ def test_add_clears_prefetched_objects(self):
+ bookwithyear = BookWithYear.objects.get(pk=self.bookwithyear1.pk)
+ prefetch_related_objects([bookwithyear], "bookreview_set")
+ self.assertCountEqual(bookwithyear.bookreview_set.all(), [self.bookreview1])
+ new_review = BookReview.objects.create()
+ bookwithyear.bookreview_set.add(new_review)
+ self.assertCountEqual(
+ bookwithyear.bookreview_set.all(), [self.bookreview1, new_review]
+ )
+
+ def test_remove_clears_prefetched_objects(self):
+ bookwithyear = BookWithYear.objects.get(pk=self.bookwithyear1.pk)
+ prefetch_related_objects([bookwithyear], "bookreview_set")
+ self.assertCountEqual(bookwithyear.bookreview_set.all(), [self.bookreview1])
+ bookwithyear.bookreview_set.remove(self.bookreview1)
+ self.assertCountEqual(bookwithyear.bookreview_set.all(), [])
+
+
+class ReadPrefetchedObjectsCacheTests(TestCase):
+ @classmethod
+ def setUpTestData(cls):
+ cls.book1 = Book.objects.create(title="Les confessions Volume I")
+ cls.book2 = Book.objects.create(title="Candide")
+ cls.author1 = AuthorWithAge.objects.create(
+ name="Rousseau", first_book=cls.book1, age=70
+ )
+ cls.author2 = AuthorWithAge.objects.create(
+ name="Voltaire", first_book=cls.book2, age=65
+ )
+ cls.book1.authors.add(cls.author1)
+ cls.book2.authors.add(cls.author2)
+ FavoriteAuthors.objects.create(author=cls.author1, likes_author=cls.author2)
+
+ def test_retrieves_results_from_prefetched_objects_cache(self):
+ """
+ When intermediary results are prefetched without a destination
+ attribute, they are saved in the RelatedManager's cache
+ (_prefetched_objects_cache). prefetch_related() uses this cache
+ (#27554).
+ """
+ authors = AuthorWithAge.objects.prefetch_related(
+ Prefetch(
+ "author",
+ queryset=Author.objects.prefetch_related(
+ # Results are saved in the RelatedManager's cache
+ # (_prefetched_objects_cache) and do not replace the
+ # RelatedManager on Author instances (favorite_authors)
+ Prefetch("favorite_authors__first_book"),
+ ),
+ ),
+ )
+ with self.assertNumQueries(4):
+ # AuthorWithAge -> Author -> FavoriteAuthors, Book
+ self.assertSequenceEqual(authors, [self.author1, self.author2])
+
+
+class NestedPrefetchTests(TestCase):
+ @classmethod
+ def setUpTestData(cls):
+ house = House.objects.create(name="Big house", address="123 Main St")
+ cls.room = Room.objects.create(name="Kitchen", house=house)
+
+ def test_nested_prefetch_is_not_overwritten_by_related_object(self):
+ """
+ The prefetched relationship is used rather than populating the reverse
+ relationship from the parent, when prefetching a set of child objects
+ related to a set of parent objects and the child queryset itself
+ specifies a prefetch back to the parent.
+ """
+ queryset = House.objects.only("name").prefetch_related(
+ Prefetch(
+ "rooms",
+ queryset=Room.objects.prefetch_related(
+ Prefetch("house", queryset=House.objects.only("address")),
+ ),
+ ),
+ )
+ with self.assertNumQueries(3):
+ house = queryset.first()
+
+ self.assertIs(Room.house.is_cached(self.room), True)
+ with self.assertNumQueries(0):
+ house.rooms.first().house.address
+
+
+class PrefetchLimitTests(TestDataMixin, TestCase):
+ @skipUnlessDBFeature("supports_over_clause")
+ def test_m2m_forward(self):
+ authors = Author.objects.all() # Meta.ordering
+ with self.assertNumQueries(3):
+ books = list(
+ Book.objects.prefetch_related(
+ Prefetch("authors", authors),
+ Prefetch("authors", authors[1:], to_attr="authors_sliced"),
+ )
+ )
+ for book in books:
+ with self.subTest(book=book):
+ self.assertEqual(book.authors_sliced, list(book.authors.all())[1:])
+
+ @skipUnlessDBFeature("supports_over_clause")
+ def test_m2m_reverse(self):
+ books = Book.objects.order_by("title")
+ with self.assertNumQueries(3):
+ authors = list(
+ Author.objects.prefetch_related(
+ Prefetch("books", books),
+ Prefetch("books", books[1:2], to_attr="books_sliced"),
+ )
+ )
+ for author in authors:
+ with self.subTest(author=author):
+ self.assertEqual(author.books_sliced, list(author.books.all())[1:2])
+
+ @skipUnlessDBFeature("supports_over_clause")
+ def test_foreignkey_reverse(self):
+ authors = Author.objects.order_by("-name")
+ with self.assertNumQueries(3):
+ books = list(
+ Book.objects.prefetch_related(
+ Prefetch(
+ "first_time_authors",
+ authors,
+ ),
+ Prefetch(
+ "first_time_authors",
+ authors[1:],
+ to_attr="first_time_authors_sliced",
+ ),
+ )
+ )
+ for book in books:
+ with self.subTest(book=book):
+ self.assertEqual(
+ book.first_time_authors_sliced,
+ list(book.first_time_authors.all())[1:],
+ )
+
+ @skipUnlessDBFeature("supports_over_clause")
+ def test_reverse_ordering(self):
+ authors = Author.objects.reverse() # Reverse Meta.ordering
+ with self.assertNumQueries(3):
+ books = list(
+ Book.objects.prefetch_related(
+ Prefetch("authors", authors),
+ Prefetch("authors", authors[1:], to_attr="authors_sliced"),
+ )
+ )
+ for book in books:
+ with self.subTest(book=book):
+ self.assertEqual(book.authors_sliced, list(book.authors.all())[1:])
+
+ @skipIfDBFeature("supports_over_clause")
+ def test_window_not_supported(self):
+ authors = Author.objects.all()
+ msg = (
+ "Prefetching from a limited queryset is only supported on backends that "
+ "support window functions."
+ )
+ with self.assertRaisesMessage(NotSupportedError, msg):
+ list(Book.objects.prefetch_related(Prefetch("authors", authors[1:])))
diff --git a/testbed/django__django/tests/project_template/__init__.py b/testbed/django__django/tests/project_template/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testbed/django__django/tests/project_template/test_settings.py b/testbed/django__django/tests/project_template/test_settings.py
new file mode 100644
index 0000000000000000000000000000000000000000..ba3dee74050332fdb7a2587abb3d81b3a60ab893
--- /dev/null
+++ b/testbed/django__django/tests/project_template/test_settings.py
@@ -0,0 +1,48 @@
+import os
+import shutil
+import tempfile
+
+from django import conf
+from django.test import SimpleTestCase
+from django.test.utils import extend_sys_path
+
+
+class TestStartProjectSettings(SimpleTestCase):
+ def setUp(self):
+ self.temp_dir = tempfile.TemporaryDirectory()
+ self.addCleanup(self.temp_dir.cleanup)
+ template_settings_py = os.path.join(
+ os.path.dirname(conf.__file__),
+ "project_template",
+ "project_name",
+ "settings.py-tpl",
+ )
+ test_settings_py = os.path.join(self.temp_dir.name, "test_settings.py")
+ shutil.copyfile(template_settings_py, test_settings_py)
+
+ def test_middleware_headers(self):
+ """
+ Ensure headers sent by the default MIDDLEWARE don't inadvertently
+ change. For example, we never want "Vary: Cookie" to appear in the list
+ since it prevents the caching of responses.
+ """
+ with extend_sys_path(self.temp_dir.name):
+ from test_settings import MIDDLEWARE
+
+ with self.settings(
+ MIDDLEWARE=MIDDLEWARE,
+ ROOT_URLCONF="project_template.urls",
+ ):
+ response = self.client.get("/empty/")
+ headers = sorted(response.serialize_headers().split(b"\r\n"))
+ self.assertEqual(
+ headers,
+ [
+ b"Content-Length: 0",
+ b"Content-Type: text/html; charset=utf-8",
+ b"Cross-Origin-Opener-Policy: same-origin",
+ b"Referrer-Policy: same-origin",
+ b"X-Content-Type-Options: nosniff",
+ b"X-Frame-Options: DENY",
+ ],
+ )
diff --git a/testbed/django__django/tests/project_template/urls.py b/testbed/django__django/tests/project_template/urls.py
new file mode 100644
index 0000000000000000000000000000000000000000..ae864b8e2d2bffb4a60c812c825c1c9757a70d47
--- /dev/null
+++ b/testbed/django__django/tests/project_template/urls.py
@@ -0,0 +1,7 @@
+from django.urls import path
+
+from . import views
+
+urlpatterns = [
+ path("empty/", views.empty_view),
+]
diff --git a/testbed/django__django/tests/project_template/views.py b/testbed/django__django/tests/project_template/views.py
new file mode 100644
index 0000000000000000000000000000000000000000..3f8e055a5300f8fa808699645de1ef0db3de37af
--- /dev/null
+++ b/testbed/django__django/tests/project_template/views.py
@@ -0,0 +1,5 @@
+from django.http import HttpResponse
+
+
+def empty_view(request, *args, **kwargs):
+ return HttpResponse()
diff --git a/testbed/django__django/tests/properties/__init__.py b/testbed/django__django/tests/properties/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testbed/django__django/tests/properties/models.py b/testbed/django__django/tests/properties/models.py
new file mode 100644
index 0000000000000000000000000000000000000000..c5b75c7d31a0dbf2d37123e44a55e50b1b97e12b
--- /dev/null
+++ b/testbed/django__django/tests/properties/models.py
@@ -0,0 +1,22 @@
+"""
+Using properties on models
+
+Use properties on models just like on any other Python object.
+"""
+
+from django.db import models
+
+
+class Person(models.Model):
+ first_name = models.CharField(max_length=30)
+ last_name = models.CharField(max_length=30)
+
+ def _get_full_name(self):
+ return "%s %s" % (self.first_name, self.last_name)
+
+ def _set_full_name(self, combined_name):
+ self.first_name, self.last_name = combined_name.split(" ", 1)
+
+ full_name = property(_get_full_name)
+
+ full_name_2 = property(_get_full_name, _set_full_name)
diff --git a/testbed/django__django/tests/properties/tests.py b/testbed/django__django/tests/properties/tests.py
new file mode 100644
index 0000000000000000000000000000000000000000..da51934d8c680ad5a648afb0332a9632942ab2f9
--- /dev/null
+++ b/testbed/django__django/tests/properties/tests.py
@@ -0,0 +1,26 @@
+from django.test import TestCase
+
+from .models import Person
+
+
+class PropertyTests(TestCase):
+ @classmethod
+ def setUpTestData(cls):
+ cls.a = Person.objects.create(first_name="John", last_name="Lennon")
+
+ def test_getter(self):
+ self.assertEqual(self.a.full_name, "John Lennon")
+
+ def test_setter(self):
+ # The "full_name" property hasn't provided a "set" method.
+ with self.assertRaises(AttributeError):
+ setattr(self.a, "full_name", "Paul McCartney")
+
+ # And cannot be used to initialize the class.
+ with self.assertRaises(AttributeError):
+ Person(full_name="Paul McCartney")
+
+ # But "full_name_2" has, and it can be used to initialize the class.
+ a2 = Person(full_name_2="Paul McCartney")
+ a2.save()
+ self.assertEqual(a2.first_name, "Paul")
diff --git a/testbed/django__django/tests/proxy_model_inheritance/__init__.py b/testbed/django__django/tests/proxy_model_inheritance/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testbed/django__django/tests/proxy_model_inheritance/app1/__init__.py b/testbed/django__django/tests/proxy_model_inheritance/app1/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testbed/django__django/tests/proxy_model_inheritance/app1/models.py b/testbed/django__django/tests/proxy_model_inheritance/app1/models.py
new file mode 100644
index 0000000000000000000000000000000000000000..9b68293b90eb4dd6278e36c35d7cca498a7029d3
--- /dev/null
+++ b/testbed/django__django/tests/proxy_model_inheritance/app1/models.py
@@ -0,0 +1,6 @@
+from app2.models import NiceModel
+
+
+class ProxyModel(NiceModel):
+ class Meta:
+ proxy = True
diff --git a/testbed/django__django/tests/proxy_model_inheritance/app2/__init__.py b/testbed/django__django/tests/proxy_model_inheritance/app2/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testbed/django__django/tests/proxy_model_inheritance/app2/models.py b/testbed/django__django/tests/proxy_model_inheritance/app2/models.py
new file mode 100644
index 0000000000000000000000000000000000000000..1ad46d108853baed24be9266700adff3dba55ce7
--- /dev/null
+++ b/testbed/django__django/tests/proxy_model_inheritance/app2/models.py
@@ -0,0 +1,5 @@
+from django.db import models
+
+
+class NiceModel(models.Model):
+ pass
diff --git a/testbed/django__django/tests/proxy_model_inheritance/models.py b/testbed/django__django/tests/proxy_model_inheritance/models.py
new file mode 100644
index 0000000000000000000000000000000000000000..ae1d24228d737c6cf3cbe2abc9aa6b9574ef4507
--- /dev/null
+++ b/testbed/django__django/tests/proxy_model_inheritance/models.py
@@ -0,0 +1,19 @@
+from django.db import models
+
+
+class ConcreteModel(models.Model):
+ pass
+
+
+class ProxyModel(ConcreteModel):
+ class Meta:
+ proxy = True
+
+
+class ConcreteModelSubclass(ProxyModel):
+ pass
+
+
+class ConcreteModelSubclassProxy(ConcreteModelSubclass):
+ class Meta:
+ proxy = True
diff --git a/testbed/django__django/tests/proxy_model_inheritance/tests.py b/testbed/django__django/tests/proxy_model_inheritance/tests.py
new file mode 100644
index 0000000000000000000000000000000000000000..5e2d1f2d8e843faaf35bade812c75d9ca6543ab5
--- /dev/null
+++ b/testbed/django__django/tests/proxy_model_inheritance/tests.py
@@ -0,0 +1,53 @@
+import os
+
+from django.core.management import call_command
+from django.test import TestCase, TransactionTestCase
+from django.test.utils import extend_sys_path
+
+from .models import (
+ ConcreteModel,
+ ConcreteModelSubclass,
+ ConcreteModelSubclassProxy,
+ ProxyModel,
+)
+
+
+class ProxyModelInheritanceTests(TransactionTestCase):
+ """
+ Proxy model inheritance across apps can result in migrate not creating the table
+ for the proxied model (as described in #12286). This test creates two dummy
+ apps and calls migrate, then verifies that the table has been created.
+ """
+
+ available_apps = []
+
+ def test_table_exists(self):
+ with extend_sys_path(os.path.dirname(os.path.abspath(__file__))):
+ with self.modify_settings(INSTALLED_APPS={"append": ["app1", "app2"]}):
+ call_command("migrate", verbosity=0, run_syncdb=True)
+ from app1.models import ProxyModel
+ from app2.models import NiceModel
+
+ self.assertEqual(NiceModel.objects.count(), 0)
+ self.assertEqual(ProxyModel.objects.count(), 0)
+
+
+class MultiTableInheritanceProxyTest(TestCase):
+ def test_model_subclass_proxy(self):
+ """
+ Deleting an instance of a model proxying a multi-table inherited
+ subclass should cascade delete down the whole inheritance chain (see
+ #18083).
+ """
+ instance = ConcreteModelSubclassProxy.objects.create()
+ instance.delete()
+ self.assertEqual(0, ConcreteModelSubclassProxy.objects.count())
+ self.assertEqual(0, ConcreteModelSubclass.objects.count())
+ self.assertEqual(0, ConcreteModel.objects.count())
+
+ def test_deletion_through_intermediate_proxy(self):
+ child = ConcreteModelSubclass.objects.create()
+ proxy = ProxyModel.objects.get(pk=child.pk)
+ proxy.delete()
+ self.assertFalse(ConcreteModel.objects.exists())
+ self.assertFalse(ConcreteModelSubclass.objects.exists())
diff --git a/testbed/django__django/tests/proxy_models/__init__.py b/testbed/django__django/tests/proxy_models/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testbed/django__django/tests/proxy_models/admin.py b/testbed/django__django/tests/proxy_models/admin.py
new file mode 100644
index 0000000000000000000000000000000000000000..0adcac3687b481151c7240d9218b57a24d59dd0b
--- /dev/null
+++ b/testbed/django__django/tests/proxy_models/admin.py
@@ -0,0 +1,7 @@
+from django.contrib import admin
+
+from .models import ProxyTrackerUser, TrackerUser
+
+site = admin.AdminSite(name="admin_proxy")
+site.register(TrackerUser)
+site.register(ProxyTrackerUser)
diff --git a/testbed/django__django/tests/proxy_models/fixtures/mypeople.json b/testbed/django__django/tests/proxy_models/fixtures/mypeople.json
new file mode 100644
index 0000000000000000000000000000000000000000..d20c8f2a6e336e5e79a9bf029fc3dc3ed6ea5b20
--- /dev/null
+++ b/testbed/django__django/tests/proxy_models/fixtures/mypeople.json
@@ -0,0 +1,9 @@
+[
+ {
+ "pk": 100,
+ "model": "proxy_models.myperson",
+ "fields": {
+ "name": "Elvis Presley"
+ }
+ }
+]
\ No newline at end of file
diff --git a/testbed/django__django/tests/proxy_models/models.py b/testbed/django__django/tests/proxy_models/models.py
new file mode 100644
index 0000000000000000000000000000000000000000..604136b5ac663dc21468e85ffd75530846dd1dcd
--- /dev/null
+++ b/testbed/django__django/tests/proxy_models/models.py
@@ -0,0 +1,228 @@
+"""
+By specifying the 'proxy' Meta attribute, model subclasses can specify that
+they will take data directly from the table of their base class table rather
+than using a new table of their own. This allows them to act as simple proxies,
+providing a modified interface to the data from the base class.
+"""
+from django.db import models
+
+# A couple of managers for testing managing overriding in proxy model cases.
+
+
+class PersonManager(models.Manager):
+ def get_queryset(self):
+ return super().get_queryset().exclude(name="fred")
+
+
+class SubManager(models.Manager):
+ def get_queryset(self):
+ return super().get_queryset().exclude(name="wilma")
+
+
+class Person(models.Model):
+ """
+ A simple concrete base class.
+ """
+
+ name = models.CharField(max_length=50)
+
+ objects = PersonManager()
+
+ def __str__(self):
+ return self.name
+
+
+class Abstract(models.Model):
+ """
+ A simple abstract base class, to be used for error checking.
+ """
+
+ data = models.CharField(max_length=10)
+
+ class Meta:
+ abstract = True
+
+
+class MyPerson(Person):
+ """
+ A proxy subclass, this should not get a new table. Overrides the default
+ manager.
+ """
+
+ class Meta:
+ proxy = True
+ ordering = ["name"]
+ permissions = (("display_users", "May display users information"),)
+
+ objects = SubManager()
+ other = PersonManager()
+
+ def has_special_name(self):
+ return self.name.lower() == "special"
+
+
+class ManagerMixin(models.Model):
+ excluder = SubManager()
+
+ class Meta:
+ abstract = True
+
+
+class OtherPerson(Person, ManagerMixin):
+ """
+ A class with the default manager from Person, plus a secondary manager.
+ """
+
+ class Meta:
+ proxy = True
+ ordering = ["name"]
+
+
+class StatusPerson(MyPerson):
+ """
+ A non-proxy subclass of a proxy, it should get a new table.
+ """
+
+ status = models.CharField(max_length=80)
+
+ objects = models.Manager()
+
+
+# We can even have proxies of proxies (and subclass of those).
+
+
+class MyPersonProxy(MyPerson):
+ class Meta:
+ proxy = True
+
+
+class LowerStatusPerson(MyPersonProxy):
+ status = models.CharField(max_length=80)
+
+ objects = models.Manager()
+
+
+class User(models.Model):
+ name = models.CharField(max_length=100)
+
+ def __str__(self):
+ return self.name
+
+
+class UserProxy(User):
+ class Meta:
+ proxy = True
+
+
+class AnotherUserProxy(User):
+ class Meta:
+ proxy = True
+
+
+class UserProxyProxy(UserProxy):
+ class Meta:
+ proxy = True
+
+
+class MultiUserProxy(UserProxy, AnotherUserProxy):
+ class Meta:
+ proxy = True
+
+
+# We can still use `select_related()` to include related models in our querysets.
+
+
+class Country(models.Model):
+ name = models.CharField(max_length=50)
+
+
+class State(models.Model):
+ name = models.CharField(max_length=50)
+ country = models.ForeignKey(Country, models.CASCADE)
+
+ def __str__(self):
+ return self.name
+
+
+class StateProxy(State):
+ class Meta:
+ proxy = True
+
+
+# Proxy models still works with filters (on related fields)
+# and select_related, even when mixed with model inheritance
+
+
+class BaseUser(models.Model):
+ name = models.CharField(max_length=255)
+
+ def __str__(self):
+ return ":".join(
+ (
+ self.__class__.__name__,
+ self.name,
+ )
+ )
+
+
+class TrackerUser(BaseUser):
+ status = models.CharField(max_length=50)
+
+
+class ProxyTrackerUser(TrackerUser):
+ class Meta:
+ proxy = True
+
+
+class Issue(models.Model):
+ summary = models.CharField(max_length=255)
+ assignee = models.ForeignKey(
+ ProxyTrackerUser, models.CASCADE, related_name="issues"
+ )
+
+ def __str__(self):
+ return ":".join(
+ (
+ self.__class__.__name__,
+ self.summary,
+ )
+ )
+
+
+class Bug(Issue):
+ version = models.CharField(max_length=50)
+ reporter = models.ForeignKey(BaseUser, models.CASCADE)
+
+
+class ProxyBug(Bug):
+ """
+ Proxy of an inherited class
+ """
+
+ class Meta:
+ proxy = True
+
+
+class ProxyProxyBug(ProxyBug):
+ """
+ A proxy of proxy model with related field
+ """
+
+ class Meta:
+ proxy = True
+
+
+class Improvement(Issue):
+ """
+ A model that has relation to a proxy model
+ or to a proxy of proxy model
+ """
+
+ version = models.CharField(max_length=50)
+ reporter = models.ForeignKey(ProxyTrackerUser, models.CASCADE)
+ associated_bug = models.ForeignKey(ProxyProxyBug, models.CASCADE)
+
+
+class ProxyImprovement(Improvement):
+ class Meta:
+ proxy = True
diff --git a/testbed/django__django/tests/proxy_models/tests.py b/testbed/django__django/tests/proxy_models/tests.py
new file mode 100644
index 0000000000000000000000000000000000000000..7caa43d4893a62c7597681af09a5922db43a4bc2
--- /dev/null
+++ b/testbed/django__django/tests/proxy_models/tests.py
@@ -0,0 +1,462 @@
+from django.contrib import admin
+from django.contrib.auth.models import User as AuthUser
+from django.contrib.contenttypes.models import ContentType
+from django.core import checks, management
+from django.db import DEFAULT_DB_ALIAS, models
+from django.db.models import signals
+from django.test import TestCase, override_settings
+from django.test.utils import isolate_apps
+from django.urls import reverse
+
+from .admin import admin as force_admin_model_registration # NOQA
+from .models import (
+ Abstract,
+ BaseUser,
+ Bug,
+ Country,
+ Improvement,
+ Issue,
+ LowerStatusPerson,
+ MultiUserProxy,
+ MyPerson,
+ MyPersonProxy,
+ OtherPerson,
+ Person,
+ ProxyBug,
+ ProxyImprovement,
+ ProxyProxyBug,
+ ProxyTrackerUser,
+ State,
+ StateProxy,
+ StatusPerson,
+ TrackerUser,
+ User,
+ UserProxy,
+ UserProxyProxy,
+)
+
+
+class ProxyModelTests(TestCase):
+ def test_same_manager_queries(self):
+ """
+ The MyPerson model should be generating the same database queries as
+ the Person model (when the same manager is used in each case).
+ """
+ my_person_sql = (
+ MyPerson.other.all().query.get_compiler(DEFAULT_DB_ALIAS).as_sql()
+ )
+ person_sql = (
+ Person.objects.order_by("name")
+ .query.get_compiler(DEFAULT_DB_ALIAS)
+ .as_sql()
+ )
+ self.assertEqual(my_person_sql, person_sql)
+
+ def test_inheritance_new_table(self):
+ """
+ The StatusPerson models should have its own table (it's using ORM-level
+ inheritance).
+ """
+ sp_sql = (
+ StatusPerson.objects.all().query.get_compiler(DEFAULT_DB_ALIAS).as_sql()
+ )
+ p_sql = Person.objects.all().query.get_compiler(DEFAULT_DB_ALIAS).as_sql()
+ self.assertNotEqual(sp_sql, p_sql)
+
+ def test_basic_proxy(self):
+ """
+ Creating a Person makes them accessible through the MyPerson proxy.
+ """
+ person = Person.objects.create(name="Foo McBar")
+ self.assertEqual(len(Person.objects.all()), 1)
+ self.assertEqual(len(MyPerson.objects.all()), 1)
+ self.assertEqual(MyPerson.objects.get(name="Foo McBar").id, person.id)
+ self.assertFalse(MyPerson.objects.get(id=person.id).has_special_name())
+
+ def test_no_proxy(self):
+ """
+ Person is not proxied by StatusPerson subclass.
+ """
+ Person.objects.create(name="Foo McBar")
+ self.assertEqual(list(StatusPerson.objects.all()), [])
+
+ def test_basic_proxy_reverse(self):
+ """
+ A new MyPerson also shows up as a standard Person.
+ """
+ MyPerson.objects.create(name="Bazza del Frob")
+ self.assertEqual(len(MyPerson.objects.all()), 1)
+ self.assertEqual(len(Person.objects.all()), 1)
+
+ LowerStatusPerson.objects.create(status="low", name="homer")
+ lsps = [lsp.name for lsp in LowerStatusPerson.objects.all()]
+ self.assertEqual(lsps, ["homer"])
+
+ def test_correct_type_proxy_of_proxy(self):
+ """
+ Correct type when querying a proxy of proxy
+ """
+ Person.objects.create(name="Foo McBar")
+ MyPerson.objects.create(name="Bazza del Frob")
+ LowerStatusPerson.objects.create(status="low", name="homer")
+ pp = sorted(mpp.name for mpp in MyPersonProxy.objects.all())
+ self.assertEqual(pp, ["Bazza del Frob", "Foo McBar", "homer"])
+
+ def test_proxy_included_in_ancestors(self):
+ """
+ Proxy models are included in the ancestors for a model's DoesNotExist
+ and MultipleObjectsReturned
+ """
+ Person.objects.create(name="Foo McBar")
+ MyPerson.objects.create(name="Bazza del Frob")
+ LowerStatusPerson.objects.create(status="low", name="homer")
+ max_id = Person.objects.aggregate(max_id=models.Max("id"))["max_id"]
+
+ with self.assertRaises(Person.DoesNotExist):
+ MyPersonProxy.objects.get(name="Zathras")
+ with self.assertRaises(Person.MultipleObjectsReturned):
+ MyPersonProxy.objects.get(id__lt=max_id + 1)
+ with self.assertRaises(Person.DoesNotExist):
+ StatusPerson.objects.get(name="Zathras")
+
+ StatusPerson.objects.create(name="Bazza Jr.")
+ StatusPerson.objects.create(name="Foo Jr.")
+ max_id = Person.objects.aggregate(max_id=models.Max("id"))["max_id"]
+
+ with self.assertRaises(Person.MultipleObjectsReturned):
+ StatusPerson.objects.get(id__lt=max_id + 1)
+
+ def test_abstract_base_with_model_fields(self):
+ msg = (
+ "Abstract base class containing model fields not permitted for proxy model "
+ "'NoAbstract'."
+ )
+ with self.assertRaisesMessage(TypeError, msg):
+
+ class NoAbstract(Abstract):
+ class Meta:
+ proxy = True
+
+ def test_too_many_concrete_classes(self):
+ msg = (
+ "Proxy model 'TooManyBases' has more than one non-abstract model base "
+ "class."
+ )
+ with self.assertRaisesMessage(TypeError, msg):
+
+ class TooManyBases(User, Person):
+ class Meta:
+ proxy = True
+
+ def test_no_base_classes(self):
+ msg = "Proxy model 'NoBaseClasses' has no non-abstract model base class."
+ with self.assertRaisesMessage(TypeError, msg):
+
+ class NoBaseClasses(models.Model):
+ class Meta:
+ proxy = True
+
+ @isolate_apps("proxy_models")
+ def test_new_fields(self):
+ class NoNewFields(Person):
+ newfield = models.BooleanField()
+
+ class Meta:
+ proxy = True
+
+ errors = NoNewFields.check()
+ expected = [
+ checks.Error(
+ "Proxy model 'NoNewFields' contains model fields.",
+ id="models.E017",
+ )
+ ]
+ self.assertEqual(errors, expected)
+
+ @override_settings(TEST_SWAPPABLE_MODEL="proxy_models.AlternateModel")
+ @isolate_apps("proxy_models")
+ def test_swappable(self):
+ class SwappableModel(models.Model):
+ class Meta:
+ swappable = "TEST_SWAPPABLE_MODEL"
+
+ class AlternateModel(models.Model):
+ pass
+
+ # You can't proxy a swapped model
+ with self.assertRaises(TypeError):
+
+ class ProxyModel(SwappableModel):
+ class Meta:
+ proxy = True
+
+ def test_myperson_manager(self):
+ Person.objects.create(name="fred")
+ Person.objects.create(name="wilma")
+ Person.objects.create(name="barney")
+
+ resp = [p.name for p in MyPerson.objects.all()]
+ self.assertEqual(resp, ["barney", "fred"])
+
+ resp = [p.name for p in MyPerson._default_manager.all()]
+ self.assertEqual(resp, ["barney", "fred"])
+
+ def test_otherperson_manager(self):
+ Person.objects.create(name="fred")
+ Person.objects.create(name="wilma")
+ Person.objects.create(name="barney")
+
+ resp = [p.name for p in OtherPerson.objects.all()]
+ self.assertEqual(resp, ["barney", "wilma"])
+
+ resp = [p.name for p in OtherPerson.excluder.all()]
+ self.assertEqual(resp, ["barney", "fred"])
+
+ resp = [p.name for p in OtherPerson._default_manager.all()]
+ self.assertEqual(resp, ["barney", "wilma"])
+
+ def test_permissions_created(self):
+ from django.contrib.auth.models import Permission
+
+ Permission.objects.get(name="May display users information")
+
+ def test_proxy_model_signals(self):
+ """
+ Test save signals for proxy models
+ """
+ output = []
+
+ def make_handler(model, event):
+ def _handler(*args, **kwargs):
+ output.append("%s %s save" % (model, event))
+
+ return _handler
+
+ h1 = make_handler("MyPerson", "pre")
+ h2 = make_handler("MyPerson", "post")
+ h3 = make_handler("Person", "pre")
+ h4 = make_handler("Person", "post")
+
+ signals.pre_save.connect(h1, sender=MyPerson)
+ signals.post_save.connect(h2, sender=MyPerson)
+ signals.pre_save.connect(h3, sender=Person)
+ signals.post_save.connect(h4, sender=Person)
+
+ MyPerson.objects.create(name="dino")
+ self.assertEqual(output, ["MyPerson pre save", "MyPerson post save"])
+
+ output = []
+
+ h5 = make_handler("MyPersonProxy", "pre")
+ h6 = make_handler("MyPersonProxy", "post")
+
+ signals.pre_save.connect(h5, sender=MyPersonProxy)
+ signals.post_save.connect(h6, sender=MyPersonProxy)
+
+ MyPersonProxy.objects.create(name="pebbles")
+
+ self.assertEqual(output, ["MyPersonProxy pre save", "MyPersonProxy post save"])
+
+ signals.pre_save.disconnect(h1, sender=MyPerson)
+ signals.post_save.disconnect(h2, sender=MyPerson)
+ signals.pre_save.disconnect(h3, sender=Person)
+ signals.post_save.disconnect(h4, sender=Person)
+ signals.pre_save.disconnect(h5, sender=MyPersonProxy)
+ signals.post_save.disconnect(h6, sender=MyPersonProxy)
+
+ def test_content_type(self):
+ ctype = ContentType.objects.get_for_model
+ self.assertIs(ctype(Person), ctype(OtherPerson))
+
+ def test_user_proxy_models(self):
+ User.objects.create(name="Bruce")
+
+ resp = [u.name for u in User.objects.all()]
+ self.assertEqual(resp, ["Bruce"])
+
+ resp = [u.name for u in UserProxy.objects.all()]
+ self.assertEqual(resp, ["Bruce"])
+
+ resp = [u.name for u in UserProxyProxy.objects.all()]
+ self.assertEqual(resp, ["Bruce"])
+
+ self.assertEqual([u.name for u in MultiUserProxy.objects.all()], ["Bruce"])
+
+ def test_proxy_for_model(self):
+ self.assertEqual(UserProxy, UserProxyProxy._meta.proxy_for_model)
+
+ def test_concrete_model(self):
+ self.assertEqual(User, UserProxyProxy._meta.concrete_model)
+
+ def test_proxy_delete(self):
+ """
+ Proxy objects can be deleted
+ """
+ User.objects.create(name="Bruce")
+ u2 = UserProxy.objects.create(name="George")
+
+ resp = [u.name for u in UserProxy.objects.all()]
+ self.assertEqual(resp, ["Bruce", "George"])
+
+ u2.delete()
+
+ resp = [u.name for u in UserProxy.objects.all()]
+ self.assertEqual(resp, ["Bruce"])
+
+ def test_proxy_update(self):
+ user = User.objects.create(name="Bruce")
+ with self.assertNumQueries(1):
+ UserProxy.objects.filter(id=user.id).update(name="George")
+ user.refresh_from_db()
+ self.assertEqual(user.name, "George")
+
+ def test_select_related(self):
+ """
+ We can still use `select_related()` to include related models in our
+ querysets.
+ """
+ country = Country.objects.create(name="Australia")
+ State.objects.create(name="New South Wales", country=country)
+
+ resp = [s.name for s in State.objects.select_related()]
+ self.assertEqual(resp, ["New South Wales"])
+
+ resp = [s.name for s in StateProxy.objects.select_related()]
+ self.assertEqual(resp, ["New South Wales"])
+
+ self.assertEqual(
+ StateProxy.objects.get(name="New South Wales").name, "New South Wales"
+ )
+
+ resp = StateProxy.objects.select_related().get(name="New South Wales")
+ self.assertEqual(resp.name, "New South Wales")
+
+ def test_filter_proxy_relation_reverse(self):
+ tu = TrackerUser.objects.create(name="Contributor", status="contrib")
+ ptu = ProxyTrackerUser.objects.get()
+ issue = Issue.objects.create(assignee=tu)
+ self.assertEqual(tu.issues.get(), issue)
+ self.assertEqual(ptu.issues.get(), issue)
+ self.assertSequenceEqual(TrackerUser.objects.filter(issues=issue), [tu])
+ self.assertSequenceEqual(ProxyTrackerUser.objects.filter(issues=issue), [ptu])
+
+ def test_proxy_bug(self):
+ contributor = ProxyTrackerUser.objects.create(
+ name="Contributor", status="contrib"
+ )
+ someone = BaseUser.objects.create(name="Someone")
+ Bug.objects.create(
+ summary="fix this",
+ version="1.1beta",
+ assignee=contributor,
+ reporter=someone,
+ )
+ pcontributor = ProxyTrackerUser.objects.create(
+ name="OtherContributor", status="proxy"
+ )
+ Improvement.objects.create(
+ summary="improve that",
+ version="1.1beta",
+ assignee=contributor,
+ reporter=pcontributor,
+ associated_bug=ProxyProxyBug.objects.all()[0],
+ )
+
+ # Related field filter on proxy
+ resp = ProxyBug.objects.get(version__icontains="beta")
+ self.assertEqual(repr(resp), "")
+
+ # Select related + filter on proxy
+ resp = ProxyBug.objects.select_related().get(version__icontains="beta")
+ self.assertEqual(repr(resp), "")
+
+ # Proxy of proxy, select_related + filter
+ resp = ProxyProxyBug.objects.select_related().get(version__icontains="beta")
+ self.assertEqual(repr(resp), "")
+
+ # Select related + filter on a related proxy field
+ resp = ProxyImprovement.objects.select_related().get(
+ reporter__name__icontains="butor"
+ )
+ self.assertEqual(
+ repr(resp), ""
+ )
+
+ # Select related + filter on a related proxy of proxy field
+ resp = ProxyImprovement.objects.select_related().get(
+ associated_bug__summary__icontains="fix"
+ )
+ self.assertEqual(
+ repr(resp), ""
+ )
+
+ def test_proxy_load_from_fixture(self):
+ management.call_command("loaddata", "mypeople.json", verbosity=0)
+ p = MyPerson.objects.get(pk=100)
+ self.assertEqual(p.name, "Elvis Presley")
+
+ def test_select_related_only(self):
+ user = ProxyTrackerUser.objects.create(name="Joe Doe", status="test")
+ issue = Issue.objects.create(summary="New issue", assignee=user)
+ qs = Issue.objects.select_related("assignee").only("assignee__status")
+ self.assertEqual(qs.get(), issue)
+
+ def test_eq(self):
+ self.assertEqual(MyPerson(id=100), Person(id=100))
+
+
+@override_settings(ROOT_URLCONF="proxy_models.urls")
+class ProxyModelAdminTests(TestCase):
+ @classmethod
+ def setUpTestData(cls):
+ cls.superuser = AuthUser.objects.create(is_superuser=True, is_staff=True)
+ cls.tu1 = ProxyTrackerUser.objects.create(name="Django Pony", status="emperor")
+ cls.i1 = Issue.objects.create(summary="Pony's Issue", assignee=cls.tu1)
+
+ def test_cascade_delete_proxy_model_admin_warning(self):
+ """
+ Test if admin gives warning about cascade deleting models referenced
+ to concrete model by deleting proxy object.
+ """
+ tracker_user = TrackerUser.objects.all()[0]
+ base_user = BaseUser.objects.all()[0]
+ issue = Issue.objects.all()[0]
+ with self.assertNumQueries(6):
+ collector = admin.utils.NestedObjects("default")
+ collector.collect(ProxyTrackerUser.objects.all())
+ self.assertIn(tracker_user, collector.edges.get(None, ()))
+ self.assertIn(base_user, collector.edges.get(None, ()))
+ self.assertIn(issue, collector.edges.get(tracker_user, ()))
+
+ def test_delete_str_in_model_admin(self):
+ """
+ Test if the admin delete page shows the correct string representation
+ for a proxy model.
+ """
+ user = TrackerUser.objects.get(name="Django Pony")
+ proxy = ProxyTrackerUser.objects.get(name="Django Pony")
+
+ user_str = 'Tracker user: %s' % (
+ reverse("admin_proxy:proxy_models_trackeruser_change", args=(user.pk,)),
+ user,
+ )
+ proxy_str = 'Proxy tracker user: %s' % (
+ reverse(
+ "admin_proxy:proxy_models_proxytrackeruser_change", args=(proxy.pk,)
+ ),
+ proxy,
+ )
+
+ self.client.force_login(self.superuser)
+ response = self.client.get(
+ reverse("admin_proxy:proxy_models_trackeruser_delete", args=(user.pk,))
+ )
+ delete_str = response.context["deleted_objects"][0]
+ self.assertEqual(delete_str, user_str)
+ response = self.client.get(
+ reverse(
+ "admin_proxy:proxy_models_proxytrackeruser_delete", args=(proxy.pk,)
+ )
+ )
+ delete_str = response.context["deleted_objects"][0]
+ self.assertEqual(delete_str, proxy_str)
diff --git a/testbed/django__django/tests/proxy_models/urls.py b/testbed/django__django/tests/proxy_models/urls.py
new file mode 100644
index 0000000000000000000000000000000000000000..50c12eace41d01e7f8aadaa992c8b1e751edfcca
--- /dev/null
+++ b/testbed/django__django/tests/proxy_models/urls.py
@@ -0,0 +1,7 @@
+from django.urls import path
+
+from .admin import site
+
+urlpatterns = [
+ path("admin/", site.urls),
+]
diff --git a/testbed/django__django/tests/queries/__init__.py b/testbed/django__django/tests/queries/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testbed/django__django/tests/queries/models.py b/testbed/django__django/tests/queries/models.py
new file mode 100644
index 0000000000000000000000000000000000000000..23c41e33742e8ab8d23dfd34490449d1318ffe77
--- /dev/null
+++ b/testbed/django__django/tests/queries/models.py
@@ -0,0 +1,790 @@
+"""
+Various complex queries that have been problematic in the past.
+"""
+import datetime
+
+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, default=datetime.datetime.now)
+
+ class Meta:
+ ordering = ["date"]
+
+
+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"}
diff --git a/testbed/django__django/tests/queries/test_bulk_update.py b/testbed/django__django/tests/queries/test_bulk_update.py
new file mode 100644
index 0000000000000000000000000000000000000000..b2688a61c88320d19f02952aed6c7b04a7b8e5f7
--- /dev/null
+++ b/testbed/django__django/tests/queries/test_bulk_update.py
@@ -0,0 +1,332 @@
+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)
+ with self.assertRaisesMessage(ValueError, msg):
+ Note.objects.bulk_update([], fields=["note"], batch_size=0)
+
+ 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)
diff --git a/testbed/django__django/tests/queries/test_contains.py b/testbed/django__django/tests/queries/test_contains.py
new file mode 100644
index 0000000000000000000000000000000000000000..2aa4badc72bb315dd57b2ecd385798426634ce29
--- /dev/null
+++ b/testbed/django__django/tests/queries/test_contains.py
@@ -0,0 +1,62 @@
+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)
diff --git a/testbed/django__django/tests/queries/test_db_returning.py b/testbed/django__django/tests/queries/test_db_returning.py
new file mode 100644
index 0000000000000000000000000000000000000000..50c164a57f94822db56121f0c86ac52bc07276a8
--- /dev/null
+++ b/testbed/django__django/tests/queries/test_db_returning.py
@@ -0,0 +1,55 @@
+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)
diff --git a/testbed/django__django/tests/queries/test_explain.py b/testbed/django__django/tests/queries/test_explain.py
new file mode 100644
index 0000000000000000000000000000000000000000..11684356b986b0a60ff237cdbff3b07af4096b20
--- /dev/null
+++ b/testbed/django__django/tests/queries/test_explain.py
@@ -0,0 +1,161 @@
+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")),
+ ]
+ if connection.features.has_select_for_update:
+ querysets.append(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) 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 not format:
+ continue
+ if format.lower() == "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.lower() == "json":
+ try:
+ json.loads(result)
+ except json.JSONDecodeError as e:
+ self.fail(
+ f"QuerySet.explain() result is not valid JSON: {e}"
+ )
+
+ 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)
+ )
+ else:
+ msg += f" {connection.display_name} does not support any 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},
+ {"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"])
+
+ def test_option_sql_injection(self):
+ qs = Tag.objects.filter(name="test")
+ options = {"SUMMARY true) SELECT 1; --": True}
+ msg = "Invalid option name: 'SUMMARY true) SELECT 1; --'"
+ with self.assertRaisesMessage(ValueError, msg):
+ qs.explain(**options)
+
+ def test_invalid_option_names(self):
+ qs = Tag.objects.filter(name="test")
+ tests = [
+ 'opt"ion',
+ "o'ption",
+ "op`tion",
+ "opti on",
+ "option--",
+ "optio\tn",
+ "o\nption",
+ "option;",
+ "你 好",
+ # [] are used by MSSQL.
+ "option[",
+ "option]",
+ ]
+ for invalid_option in tests:
+ with self.subTest(invalid_option):
+ msg = f"Invalid option name: {invalid_option!r}"
+ with self.assertRaisesMessage(ValueError, msg):
+ qs.explain(**{invalid_option: True})
+
+ @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()
diff --git a/testbed/django__django/tests/queries/test_iterator.py b/testbed/django__django/tests/queries/test_iterator.py
new file mode 100644
index 0000000000000000000000000000000000000000..558bd15c0202db1e5dcf0bb517ff261c344cc70a
--- /dev/null
+++ b/testbed/django__django/tests/queries/test_iterator.py
@@ -0,0 +1,58 @@
+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)
diff --git a/testbed/django__django/tests/queries/test_qs_combinators.py b/testbed/django__django/tests/queries/test_qs_combinators.py
new file mode 100644
index 0000000000000000000000000000000000000000..71d2418f2b24c11ee4bc96dd85fca89dd4034509
--- /dev/null
+++ b/testbed/django__django/tests/queries/test_qs_combinators.py
@@ -0,0 +1,669 @@
+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)
+
+ def test_union_none_slice(self):
+ qs1 = Number.objects.filter(num__lte=0)
+ qs2 = Number.objects.none()
+ qs3 = qs1.union(qs2)
+ self.assertNumbersEqual(qs3[:1], [0])
+
+ def test_union_empty_filter_slice(self):
+ qs1 = Number.objects.filter(num__lte=0)
+ qs2 = Number.objects.filter(pk__in=[])
+ qs3 = qs1.union(qs2)
+ self.assertNumbersEqual(qs3[:1], [0])
+
+ @skipUnlessDBFeature("supports_slicing_ordering_in_compound")
+ def test_union_slice_compound_empty(self):
+ qs1 = Number.objects.filter(num__lte=0)[:1]
+ qs2 = Number.objects.none()
+ qs3 = qs1.union(qs2)
+ self.assertNumbersEqual(qs3[:1], [0])
+
+ @skipUnlessDBFeature("supports_slicing_ordering_in_compound")
+ def test_union_combined_slice_compound_empty(self):
+ qs1 = Number.objects.filter(num__lte=2)[:3]
+ qs2 = Number.objects.none()
+ qs3 = qs1.union(qs2)
+ self.assertNumbersEqual(qs3.order_by("num")[2:3], [2])
+
+ def test_union_slice_index(self):
+ Celebrity.objects.create(name="Famous")
+ c1 = Celebrity.objects.create(name="Very famous")
+
+ qs1 = Celebrity.objects.filter(name="nonexistent")
+ qs2 = Celebrity.objects.all()
+ combined_qs = qs1.union(qs2).order_by("name")
+ self.assertEqual(combined_qs[1], c1)
+
+ def test_union_order_with_null_first_last(self):
+ Number.objects.filter(other_num=5).update(other_num=None)
+ qs1 = Number.objects.filter(num__lte=1)
+ qs2 = Number.objects.filter(num__gte=2)
+ qs3 = qs1.union(qs2)
+ self.assertSequenceEqual(
+ qs3.order_by(
+ F("other_num").asc(nulls_first=True),
+ ).values_list("other_num", flat=True),
+ [None, 1, 2, 3, 4, 6, 7, 8, 9, 10],
+ )
+ self.assertSequenceEqual(
+ qs3.order_by(
+ F("other_num").asc(nulls_last=True),
+ ).values_list("other_num", flat=True),
+ [1, 2, 3, 4, 6, 7, 8, 9, 10, None],
+ )
+
+ def test_union_nested(self):
+ qs1 = Number.objects.all()
+ qs2 = qs1.union(qs1)
+ self.assertNumbersEqual(
+ qs1.union(qs2),
+ [0, 1, 2, 3, 4, 5, 6, 7, 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), (1, 2)])
+
+ 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_with_select_related_and_order(self):
+ e1 = ExtraInfo.objects.create(value=7, info="e1")
+ a1 = Author.objects.create(name="a1", num=1, extra=e1)
+ a2 = Author.objects.create(name="a2", num=3, extra=e1)
+ Author.objects.create(name="a3", num=2, extra=e1)
+ base_qs = Author.objects.select_related("extra").order_by()
+ qs1 = base_qs.filter(name="a1")
+ qs2 = base_qs.filter(name="a2")
+ self.assertSequenceEqual(qs1.union(qs2).order_by("pk"), [a1, a2])
+
+ @skipUnlessDBFeature("supports_slicing_ordering_in_compound")
+ def test_union_with_select_related_and_first(self):
+ e1 = ExtraInfo.objects.create(value=7, info="e1")
+ a1 = Author.objects.create(name="a1", num=1, extra=e1)
+ Author.objects.create(name="a2", num=3, extra=e1)
+ base_qs = Author.objects.select_related("extra").order_by()
+ qs1 = base_qs.filter(name="a1")
+ qs2 = base_qs.filter(name="a2")
+ self.assertEqual(qs1.union(qs2).order_by("name").first(), a1)
+
+ def test_union_with_first(self):
+ e1 = ExtraInfo.objects.create(value=7, info="e1")
+ a1 = Author.objects.create(name="a1", num=1, extra=e1)
+ base_qs = Author.objects.order_by()
+ qs1 = base_qs.filter(name="a1")
+ qs2 = base_qs.filter(name="a2")
+ self.assertEqual(qs1.union(qs2).first(), a1)
+
+ 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_multiple_models_with_values_list_and_annotations(self):
+ ReservedName.objects.create(name="rn1", order=10)
+ Celebrity.objects.create(name="c1")
+ qs1 = ReservedName.objects.annotate(row_type=Value("rn")).values_list(
+ "name", "order", "row_type"
+ )
+ qs2 = Celebrity.objects.annotate(
+ row_type=Value("cb"), order=Value(-10)
+ ).values_list("name", "order", "row_type")
+ self.assertSequenceEqual(
+ qs1.union(qs2).order_by("order"),
+ [("c1", -10, "cb"), ("rn1", 10, "rn")],
+ )
+
+ 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"])
+
+ @skipUnlessDBFeature("supports_slicing_ordering_in_compound")
+ def test_union_in_with_ordering(self):
+ qs1 = Number.objects.filter(num__gt=7).order_by("num")
+ qs2 = Number.objects.filter(num__lt=2).order_by("num")
+ self.assertNumbersEqual(
+ Number.objects.exclude(id__in=qs1.union(qs2).values("id")),
+ [2, 3, 4, 5, 6, 7],
+ ordered=False,
+ )
+
+ @skipUnlessDBFeature(
+ "supports_slicing_ordering_in_compound", "allow_sliced_subqueries_with_in"
+ )
+ def test_union_in_with_ordering_and_slice(self):
+ qs1 = Number.objects.filter(num__gt=7).order_by("num")[:1]
+ qs2 = Number.objects.filter(num__lt=2).order_by("-num")[:1]
+ self.assertNumbersEqual(
+ Number.objects.exclude(id__in=qs1.union(qs2).values("id")),
+ [0, 2, 3, 4, 5, 6, 7, 9],
+ ordered=False,
+ )
+
+ 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)
+
+ def test_count_union_with_select_related(self):
+ e1 = ExtraInfo.objects.create(value=1, info="e1")
+ Author.objects.create(name="a1", num=1, extra=e1)
+ qs = Author.objects.select_related("extra").order_by()
+ self.assertEqual(qs.union(qs).count(), 1)
+
+ @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)), 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_),
+ ("^", operator.xor),
+ ]
+ 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)
diff --git a/testbed/django__django/tests/queries/test_query.py b/testbed/django__django/tests/queries/test_query.py
new file mode 100644
index 0000000000000000000000000000000000000000..99d0e32427efc5e6c0f8439d92d95b943ddcb589
--- /dev/null
+++ b/testbed/django__django/tests/queries/test_query.py
@@ -0,0 +1,218 @@
+from datetime import datetime
+
+from django.core.exceptions import FieldError
+from django.db import DEFAULT_DB_ALIAS, connection
+from django.db.models import BooleanField, CharField, F, Q
+from django.db.models.expressions import (
+ Col,
+ Exists,
+ ExpressionWrapper,
+ Func,
+ RawSQL,
+ Value,
+)
+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.constants import SINGLE
+from django.db.models.sql.query import JoinPromoter, Query, get_field_names_from_opts
+from django.db.models.sql.where import AND, OR
+from django.test import SimpleTestCase, TestCase, skipUnlessDBFeature
+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 TestQueryNoModel(TestCase):
+ def test_rawsql_annotation(self):
+ query = Query(None)
+ sql = "%s = 1"
+ # Wrap with a CASE WHEN expression if a database backend (e.g. Oracle)
+ # doesn't support boolean expression in SELECT list.
+ if not connection.features.supports_boolean_expr_in_select_clause:
+ sql = f"CASE WHEN {sql} THEN 1 ELSE 0 END"
+ query.add_annotation(RawSQL(sql, (1,), BooleanField()), "_check")
+ result = query.get_compiler(using=DEFAULT_DB_ALIAS).execute_sql(SINGLE)
+ self.assertEqual(result[0], 1)
+
+ def test_subquery_annotation(self):
+ query = Query(None)
+ query.add_annotation(Exists(Item.objects.all()), "_check")
+ result = query.get_compiler(using=DEFAULT_DB_ALIAS).execute_sql(SINGLE)
+ self.assertEqual(result[0], 0)
+
+ @skipUnlessDBFeature("supports_boolean_expr_in_select_clause")
+ def test_q_annotation(self):
+ query = Query(None)
+ check = ExpressionWrapper(
+ Q(RawSQL("%s = 1", (1,), BooleanField())) | Q(Exists(Item.objects.all())),
+ BooleanField(),
+ )
+ query.add_annotation(check, "_check")
+ result = query.get_compiler(using=DEFAULT_DB_ALIAS).execute_sql(SINGLE)
+ self.assertEqual(result[0], 1)
+
+ def test_names_to_path_field(self):
+ query = Query(None)
+ query.add_annotation(Value(True), "value")
+ path, final_field, targets, names = query.names_to_path(["value"], opts=None)
+ self.assertEqual(path, [])
+ self.assertIsInstance(final_field, BooleanField)
+ self.assertEqual(len(targets), 1)
+ self.assertIsInstance(targets[0], BooleanField)
+ self.assertEqual(names, [])
+
+ def test_names_to_path_field_error(self):
+ query = Query(None)
+ msg = "Cannot resolve keyword 'nonexistent' into field."
+ with self.assertRaisesMessage(FieldError, msg):
+ query.names_to_path(["nonexistent"], opts=None)
+
+ def test_get_field_names_from_opts(self):
+ self.assertEqual(get_field_names_from_opts(None), set())
+
+
+class JoinPromoterTest(SimpleTestCase):
+ def test_repr(self):
+ self.assertEqual(
+ repr(JoinPromoter(AND, 3, True)),
+ "JoinPromoter(connector='AND', num_children=3, negated=True)",
+ )
diff --git a/testbed/django__django/tests/queries/test_sqlcompiler.py b/testbed/django__django/tests/queries/test_sqlcompiler.py
new file mode 100644
index 0000000000000000000000000000000000000000..72a66ad07ca5639a51d74f646e89d4edb94ac4fe
--- /dev/null
+++ b/testbed/django__django/tests/queries/test_sqlcompiler.py
@@ -0,0 +1,17 @@
+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" "
+ f"using='default'>",
+ )
diff --git a/testbed/django__django/tests/queries/tests.py b/testbed/django__django/tests/queries/tests.py
new file mode 100644
index 0000000000000000000000000000000000000000..43cfd9b7c0d21e5026576253ef8fb2fe33c7a16d
--- /dev/null
+++ b/testbed/django__django/tests/queries/tests.py
@@ -0,0 +1,4582 @@
+import datetime
+import pickle
+import sys
+import unittest
+from operator import attrgetter
+from threading import Lock
+
+from django.core.exceptions import EmptyResultSet, FieldError, FullResultSet
+from django.db import DEFAULT_DB_ALIAS, connection
+from django.db.models import CharField, Count, Exists, F, Max, OuterRef, Q
+from django.db.models.expressions import RawSQL
+from django.db.models.functions import ExtractYear, Length, LTrim
+from django.db.models.sql.constants import LOUTER
+from django.db.models.sql.where import AND, OR, NothingNode, WhereNode
+from django.test import SimpleTestCase, TestCase, skipUnlessDBFeature
+from django.test.utils import CaptureQueriesContext, register_lookup
+
+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_order_by_related_field_transform(self):
+ extra_12 = ExtraInfo.objects.create(
+ info="extra 12",
+ date=DateTimePK.objects.create(date=datetime.datetime(2021, 12, 10)),
+ )
+ extra_11 = ExtraInfo.objects.create(
+ info="extra 11",
+ date=DateTimePK.objects.create(date=datetime.datetime(2022, 11, 10)),
+ )
+ self.assertSequenceEqual(
+ ExtraInfo.objects.filter(date__isnull=False).order_by("date__month"),
+ [extra_11, extra_12],
+ )
+
+ def test_filter_by_related_field_transform(self):
+ extra_old = ExtraInfo.objects.create(
+ info="extra 12",
+ date=DateTimePK.objects.create(date=datetime.datetime(2020, 12, 10)),
+ )
+ ExtraInfo.objects.create(info="extra 11", date=DateTimePK.objects.create())
+ a5 = Author.objects.create(name="a5", num=5005, extra=extra_old)
+
+ fk_field = ExtraInfo._meta.get_field("date")
+ with register_lookup(fk_field, ExtractYear):
+ self.assertSequenceEqual(
+ ExtraInfo.objects.filter(date__year=2020),
+ [extra_old],
+ )
+ self.assertSequenceEqual(
+ Author.objects.filter(extra__date__year=2020), [a5]
+ )
+
+ def test_filter_by_related_field_nested_transforms(self):
+ extra = ExtraInfo.objects.create(info=" extra")
+ a5 = Author.objects.create(name="a5", num=5005, extra=extra)
+ info_field = ExtraInfo._meta.get_field("info")
+ with register_lookup(info_field, Length), register_lookup(CharField, LTrim):
+ self.assertSequenceEqual(
+ Author.objects.filter(extra__info__ltrim__length=5), [a5]
+ )
+
+ 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), "")
+ self.assertEqual(repr(qs[0].creator.extra.note), "")
+
+ 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.assertSequenceEqual(q.all(), [])
+ self.assertSequenceEqual(q.filter(meal="m"), [])
+ self.assertSequenceEqual(q.exclude(meal="m"), [])
+ self.assertSequenceEqual(q.complex_filter({"pk": 1}), [])
+ self.assertSequenceEqual(q.select_related("food"), [])
+ self.assertSequenceEqual(q.annotate(Count("food")), [])
+ self.assertSequenceEqual(q.order_by("meal", "food"), [])
+ self.assertSequenceEqual(q.distinct(), [])
+ self.assertSequenceEqual(q.extra(select={"foo": "1"}), [])
+ self.assertSequenceEqual(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.assertSequenceEqual(q.defer("meal"), [])
+ self.assertSequenceEqual(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.assertSequenceEqual(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.assertSequenceEqual(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 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.assertSequenceEqual(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.assertSequenceEqual(
+ 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.assertCountEqual(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.assertCountEqual(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],
+ )
+ 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_extra_select_alias_sql_injection(self):
+ crafted_alias = """injected_name" from "queries_note"; --"""
+ msg = (
+ "Column aliases cannot contain whitespace characters, quotation marks, "
+ "semicolons, or SQL comments."
+ )
+ with self.assertRaisesMessage(ValueError, msg):
+ Note.objects.extra(select={crafted_alias: "1"})
+
+ 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):
+ msg = "Model instances passed to related filters must be saved."
+ company = Company.objects.create(name="Django")
+ with self.assertRaisesMessage(ValueError, msg):
+ Employment.objects.filter(employer=Company(name="unsaved"))
+ with self.assertRaisesMessage(ValueError, msg):
+ Employment.objects.filter(employer__in=[company, Company(name="unsaved")])
+ with self.assertRaisesMessage(ValueError, 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.assertSequenceEqual(X.objects.all(), [])
+ self.assertSequenceEqual(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)), "")
+ self.assertEqual(repr(next(i1)), "")
+ self.assertEqual(repr(next(i2)), "")
+ self.assertEqual(repr(next(i2)), "")
+ self.assertEqual(repr(next(i2)), "")
+ self.assertEqual(repr(next(i1)), "")
+
+ 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)
+
+ def test_xor_subquery(self):
+ self.assertSequenceEqual(
+ Tag.objects.filter(
+ Exists(Tag.objects.filter(id=OuterRef("id"), name="t3"))
+ ^ Exists(Tag.objects.filter(id=OuterRef("id"), parent=self.t1))
+ ),
+ [self.t2],
+ )
+
+
+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), ""
+ )
+
+ 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),
+ "",
+ )
+
+
+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_distinct_exists(self):
+ with CaptureQueriesContext(connection) as captured_queries:
+ self.assertIs(Article.objects.distinct().exists(), False)
+ self.assertEqual(len(captured_queries), 1)
+ captured_sql = captured_queries[0]["sql"]
+ self.assertNotIn(connection.ops.quote_name("id"), captured_sql)
+ self.assertNotIn(connection.ops.quote_name("name"), captured_sql)
+
+ def test_sliced_distinct_exists(self):
+ with CaptureQueriesContext(connection) as captured_queries:
+ self.assertIs(Article.objects.distinct()[1:3].exists(), False)
+ self.assertEqual(len(captured_queries), 1)
+ captured_sql = captured_queries[0]["sql"]
+ self.assertIn(connection.ops.quote_name("id"), captured_sql)
+ self.assertIn(connection.ops.quote_name("name"), captured_sql)
+
+ 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])
+
+ @skipUnlessDBFeature("allow_sliced_subqueries_with_in")
+ def test_xor_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_xor_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_xor_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_xor_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.assertSequenceEqual(Article.objects.all()[0:0], [])
+ self.assertSequenceEqual(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.assertSequenceEqual(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_exclude_m2m_through(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")
+ )
+ with self.assertNumQueries(1) as ctx:
+ self.assertSequenceEqual(alex_nontech_employers, [google, intel, microsoft])
+ sql = ctx.captured_queries[0]["sql"]
+ # Company's ID should appear in SELECT and INNER JOIN, not in EXISTS as
+ # the outer query reference is not necessary when an alias is reused.
+ company_id = "%s.%s" % (
+ connection.ops.quote_name(Company._meta.db_table),
+ connection.ops.quote_name(Company._meta.get_field("id").column),
+ )
+ self.assertEqual(sql.count(company_id), 2)
+
+ 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],
+ )
+
+ def test_exclude_unsaved_object(self):
+ company = Company.objects.create(name="Django")
+ msg = "Model instances passed to related filters must be saved."
+ with self.assertRaisesMessage(ValueError, msg):
+ Employment.objects.exclude(employer=Company(name="unsaved"))
+ with self.assertRaisesMessage(ValueError, msg):
+ Employment.objects.exclude(employer__in=[company, Company(name="unsaved")])
+ with self.assertRaisesMessage(ValueError, 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.assertSequenceEqual(
+ 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()
+ with self.assertRaises(FullResultSet):
+ 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()
+ with self.assertRaises(FullResultSet):
+ 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()
+ with self.assertRaises(FullResultSet):
+ 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])
+ with self.assertRaises(FullResultSet):
+ 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()
+ with self.assertRaises(FullResultSet):
+ w.as_sql(compiler, connection)
+ w = WhereNode(children=[empty_w, NothingNode()], connector=OR)
+ with self.assertRaises(FullResultSet):
+ 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_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.assertSequenceEqual(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])
diff --git a/testbed/django__django/tests/queryset_pickle/__init__.py b/testbed/django__django/tests/queryset_pickle/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testbed/django__django/tests/queryset_pickle/models.py b/testbed/django__django/tests/queryset_pickle/models.py
new file mode 100644
index 0000000000000000000000000000000000000000..033cd2bbf96a00058e08f8b89d2ace192aa4c943
--- /dev/null
+++ b/testbed/django__django/tests/queryset_pickle/models.py
@@ -0,0 +1,79 @@
+import datetime
+
+from django.db import DJANGO_VERSION_PICKLE_KEY, models
+from django.utils.translation import gettext_lazy as _
+
+
+def standalone_number():
+ return 1
+
+
+class Numbers:
+ @staticmethod
+ def get_static_number():
+ return 2
+
+
+class PreviousDjangoVersionQuerySet(models.QuerySet):
+ def __getstate__(self):
+ state = super().__getstate__()
+ state[DJANGO_VERSION_PICKLE_KEY] = "1.0"
+ return state
+
+
+class MissingDjangoVersionQuerySet(models.QuerySet):
+ def __getstate__(self):
+ state = super().__getstate__()
+ del state[DJANGO_VERSION_PICKLE_KEY]
+ return state
+
+
+class Group(models.Model):
+ name = models.CharField(_("name"), max_length=100)
+ objects = models.Manager()
+ previous_django_version_objects = PreviousDjangoVersionQuerySet.as_manager()
+ missing_django_version_objects = MissingDjangoVersionQuerySet.as_manager()
+
+
+class Event(models.Model):
+ title = models.CharField(max_length=100)
+ group = models.ForeignKey(Group, models.CASCADE, limit_choices_to=models.Q())
+
+
+class Happening(models.Model):
+ when = models.DateTimeField(blank=True, default=datetime.datetime.now)
+ name = models.CharField(blank=True, max_length=100, default="test")
+ number1 = models.IntegerField(blank=True, default=standalone_number)
+ number2 = models.IntegerField(blank=True, default=Numbers.get_static_number)
+ event = models.OneToOneField(Event, models.CASCADE, null=True)
+
+
+class BinaryFieldModel(models.Model):
+ data = models.BinaryField(null=True)
+
+
+class Container:
+ # To test pickling we need a class that isn't defined on module, but
+ # is still available from app-cache. So, the Container class moves
+ # SomeModel outside of module level
+ class SomeModel(models.Model):
+ somefield = models.IntegerField()
+
+
+class M2MModel(models.Model):
+ added = models.DateField(default=datetime.date.today)
+ groups = models.ManyToManyField(Group)
+
+
+class AbstractEvent(Event):
+ class Meta:
+ abstract = True
+ ordering = ["title"]
+
+
+class MyEvent(AbstractEvent):
+ pass
+
+
+class Edition(models.Model):
+ event = models.ForeignKey("MyEvent", on_delete=models.CASCADE)
diff --git a/testbed/django__django/tests/queryset_pickle/tests.py b/testbed/django__django/tests/queryset_pickle/tests.py
new file mode 100644
index 0000000000000000000000000000000000000000..337c5193ce1b4edac32ab3af9ea90fd83ee3304f
--- /dev/null
+++ b/testbed/django__django/tests/queryset_pickle/tests.py
@@ -0,0 +1,390 @@
+import datetime
+import pickle
+
+import django
+from django.db import models
+from django.test import TestCase
+
+from .models import (
+ BinaryFieldModel,
+ Container,
+ Event,
+ Group,
+ Happening,
+ M2MModel,
+ MyEvent,
+)
+
+
+class PickleabilityTestCase(TestCase):
+ @classmethod
+ def setUpTestData(cls):
+ cls.happening = (
+ Happening.objects.create()
+ ) # make sure the defaults are working (#20158)
+
+ def assert_pickles(self, qs):
+ self.assertEqual(list(pickle.loads(pickle.dumps(qs))), list(qs))
+
+ def test_binaryfield(self):
+ BinaryFieldModel.objects.create(data=b"binary data")
+ self.assert_pickles(BinaryFieldModel.objects.all())
+
+ def test_related_field(self):
+ g = Group.objects.create(name="Ponies Who Own Maybachs")
+ self.assert_pickles(Event.objects.filter(group=g.id))
+
+ def test_datetime_callable_default_all(self):
+ self.assert_pickles(Happening.objects.all())
+
+ def test_datetime_callable_default_filter(self):
+ self.assert_pickles(Happening.objects.filter(when=datetime.datetime.now()))
+
+ def test_string_as_default(self):
+ self.assert_pickles(Happening.objects.filter(name="test"))
+
+ def test_standalone_method_as_default(self):
+ self.assert_pickles(Happening.objects.filter(number1=1))
+
+ def test_staticmethod_as_default(self):
+ self.assert_pickles(Happening.objects.filter(number2=1))
+
+ def test_filter_reverse_fk(self):
+ self.assert_pickles(Group.objects.filter(event=1))
+
+ def test_doesnotexist_exception(self):
+ # Ticket #17776
+ original = Event.DoesNotExist("Doesn't exist")
+ unpickled = pickle.loads(pickle.dumps(original))
+
+ # Exceptions are not equal to equivalent instances of themselves, so
+ # can't just use assertEqual(original, unpickled)
+ self.assertEqual(original.__class__, unpickled.__class__)
+ self.assertEqual(original.args, unpickled.args)
+
+ def test_doesnotexist_class(self):
+ klass = Event.DoesNotExist
+ self.assertIs(pickle.loads(pickle.dumps(klass)), klass)
+
+ def test_multipleobjectsreturned_class(self):
+ klass = Event.MultipleObjectsReturned
+ self.assertIs(pickle.loads(pickle.dumps(klass)), klass)
+
+ def test_forward_relatedobjectdoesnotexist_class(self):
+ # ForwardManyToOneDescriptor
+ klass = Event.group.RelatedObjectDoesNotExist
+ self.assertIs(pickle.loads(pickle.dumps(klass)), klass)
+ # ForwardOneToOneDescriptor
+ klass = Happening.event.RelatedObjectDoesNotExist
+ self.assertIs(pickle.loads(pickle.dumps(klass)), klass)
+
+ def test_reverse_one_to_one_relatedobjectdoesnotexist_class(self):
+ klass = Event.happening.RelatedObjectDoesNotExist
+ self.assertIs(pickle.loads(pickle.dumps(klass)), klass)
+
+ def test_manager_pickle(self):
+ pickle.loads(pickle.dumps(Happening.objects))
+
+ def test_model_pickle(self):
+ """
+ A model not defined on module level is picklable.
+ """
+ original = Container.SomeModel(pk=1)
+ dumped = pickle.dumps(original)
+ reloaded = pickle.loads(dumped)
+ self.assertEqual(original, reloaded)
+ # Also, deferred dynamic model works
+ Container.SomeModel.objects.create(somefield=1)
+ original = Container.SomeModel.objects.defer("somefield")[0]
+ dumped = pickle.dumps(original)
+ reloaded = pickle.loads(dumped)
+ self.assertEqual(original, reloaded)
+ self.assertEqual(original.somefield, reloaded.somefield)
+
+ def test_model_pickle_m2m(self):
+ """
+ Test intentionally the automatically created through model.
+ """
+ m1 = M2MModel.objects.create()
+ g1 = Group.objects.create(name="foof")
+ m1.groups.add(g1)
+ m2m_through = M2MModel._meta.get_field("groups").remote_field.through
+ original = m2m_through.objects.get()
+ dumped = pickle.dumps(original)
+ reloaded = pickle.loads(dumped)
+ self.assertEqual(original, reloaded)
+
+ def test_model_pickle_dynamic(self):
+ class Meta:
+ proxy = True
+
+ dynclass = type(
+ "DynamicEventSubclass",
+ (Event,),
+ {"Meta": Meta, "__module__": Event.__module__},
+ )
+ original = dynclass(pk=1)
+ dumped = pickle.dumps(original)
+ reloaded = pickle.loads(dumped)
+ self.assertEqual(original, reloaded)
+ self.assertIs(reloaded.__class__, dynclass)
+
+ def test_specialized_queryset(self):
+ self.assert_pickles(Happening.objects.values("name"))
+ self.assert_pickles(Happening.objects.values("name").dates("when", "year"))
+ # With related field (#14515)
+ self.assert_pickles(
+ Event.objects.select_related("group")
+ .order_by("title")
+ .values_list("title", "group__name")
+ )
+
+ def test_pickle_prefetch_related_idempotence(self):
+ g = Group.objects.create(name="foo")
+ groups = Group.objects.prefetch_related("event_set")
+
+ # First pickling
+ groups = pickle.loads(pickle.dumps(groups))
+ self.assertSequenceEqual(groups, [g])
+
+ # Second pickling
+ groups = pickle.loads(pickle.dumps(groups))
+ self.assertSequenceEqual(groups, [g])
+
+ def test_pickle_prefetch_queryset_usable_outside_of_prefetch(self):
+ # Prefetch shouldn't affect the fetch-on-pickle behavior of the
+ # queryset passed to it.
+ Group.objects.create(name="foo")
+ events = Event.objects.order_by("id")
+ Group.objects.prefetch_related(models.Prefetch("event_set", queryset=events))
+ with self.assertNumQueries(1):
+ events2 = pickle.loads(pickle.dumps(events))
+ with self.assertNumQueries(0):
+ list(events2)
+
+ def test_pickle_prefetch_queryset_still_usable(self):
+ g = Group.objects.create(name="foo")
+ groups = Group.objects.prefetch_related(
+ models.Prefetch("event_set", queryset=Event.objects.order_by("id"))
+ )
+ groups2 = pickle.loads(pickle.dumps(groups))
+ self.assertSequenceEqual(groups2.filter(id__gte=0), [g])
+
+ def test_pickle_prefetch_queryset_not_evaluated(self):
+ Group.objects.create(name="foo")
+ groups = Group.objects.prefetch_related(
+ models.Prefetch("event_set", queryset=Event.objects.order_by("id"))
+ )
+ list(groups) # evaluate QuerySet
+ with self.assertNumQueries(0):
+ pickle.loads(pickle.dumps(groups))
+
+ def test_pickle_prefetch_related_with_m2m_and_objects_deletion(self):
+ """
+ #24831 -- Cached properties on ManyToOneRel created in QuerySet.delete()
+ caused subsequent QuerySet pickling to fail.
+ """
+ g = Group.objects.create(name="foo")
+ m2m = M2MModel.objects.create()
+ m2m.groups.add(g)
+ Group.objects.all().delete()
+
+ m2ms = M2MModel.objects.prefetch_related("groups")
+ m2ms = pickle.loads(pickle.dumps(m2ms))
+ self.assertSequenceEqual(m2ms, [m2m])
+
+ def test_pickle_boolean_expression_in_Q__queryset(self):
+ group = Group.objects.create(name="group")
+ Event.objects.create(title="event", group=group)
+ groups = Group.objects.filter(
+ models.Q(
+ models.Exists(
+ Event.objects.filter(group_id=models.OuterRef("id")),
+ )
+ ),
+ )
+ groups2 = pickle.loads(pickle.dumps(groups))
+ self.assertSequenceEqual(groups2, [group])
+
+ def test_pickle_exists_queryset_still_usable(self):
+ group = Group.objects.create(name="group")
+ Event.objects.create(title="event", group=group)
+ groups = Group.objects.annotate(
+ has_event=models.Exists(
+ Event.objects.filter(group_id=models.OuterRef("id")),
+ ),
+ )
+ groups2 = pickle.loads(pickle.dumps(groups))
+ self.assertSequenceEqual(groups2.filter(has_event=True), [group])
+
+ def test_pickle_exists_queryset_not_evaluated(self):
+ group = Group.objects.create(name="group")
+ Event.objects.create(title="event", group=group)
+ groups = Group.objects.annotate(
+ has_event=models.Exists(
+ Event.objects.filter(group_id=models.OuterRef("id")),
+ ),
+ )
+ list(groups) # evaluate QuerySet.
+ with self.assertNumQueries(0):
+ self.assert_pickles(groups)
+
+ def test_pickle_exists_kwargs_queryset_not_evaluated(self):
+ group = Group.objects.create(name="group")
+ Event.objects.create(title="event", group=group)
+ groups = Group.objects.annotate(
+ has_event=models.Exists(
+ queryset=Event.objects.filter(group_id=models.OuterRef("id")),
+ ),
+ )
+ list(groups) # evaluate QuerySet.
+ with self.assertNumQueries(0):
+ self.assert_pickles(groups)
+
+ def test_pickle_subquery_queryset_not_evaluated(self):
+ group = Group.objects.create(name="group")
+ Event.objects.create(title="event", group=group)
+ groups = Group.objects.annotate(
+ event_title=models.Subquery(
+ Event.objects.filter(group_id=models.OuterRef("id")).values("title"),
+ ),
+ )
+ list(groups) # evaluate QuerySet.
+ with self.assertNumQueries(0):
+ self.assert_pickles(groups)
+
+ def test_pickle_filteredrelation(self):
+ group = Group.objects.create(name="group")
+ event_1 = Event.objects.create(title="Big event", group=group)
+ event_2 = Event.objects.create(title="Small event", group=group)
+ Happening.objects.bulk_create(
+ [
+ Happening(event=event_1, number1=5),
+ Happening(event=event_2, number1=3),
+ ]
+ )
+ groups = Group.objects.annotate(
+ big_events=models.FilteredRelation(
+ "event",
+ condition=models.Q(event__title__startswith="Big"),
+ ),
+ ).annotate(sum_number=models.Sum("big_events__happening__number1"))
+ groups_query = pickle.loads(pickle.dumps(groups.query))
+ groups = Group.objects.all()
+ groups.query = groups_query
+ self.assertEqual(groups.get().sum_number, 5)
+
+ def test_pickle_filteredrelation_m2m(self):
+ group = Group.objects.create(name="group")
+ m2mmodel = M2MModel.objects.create(added=datetime.date(2020, 1, 1))
+ m2mmodel.groups.add(group)
+ groups = Group.objects.annotate(
+ first_m2mmodels=models.FilteredRelation(
+ "m2mmodel",
+ condition=models.Q(m2mmodel__added__year=2020),
+ ),
+ ).annotate(count_groups=models.Count("first_m2mmodels__groups"))
+ groups_query = pickle.loads(pickle.dumps(groups.query))
+ groups = Group.objects.all()
+ groups.query = groups_query
+ self.assertEqual(groups.get().count_groups, 1)
+
+ def test_annotation_with_callable_default(self):
+ # Happening.when has a callable default of datetime.datetime.now.
+ qs = Happening.objects.annotate(latest_time=models.Max("when"))
+ self.assert_pickles(qs)
+
+ def test_annotation_values(self):
+ qs = Happening.objects.values("name").annotate(latest_time=models.Max("when"))
+ reloaded = Happening.objects.all()
+ reloaded.query = pickle.loads(pickle.dumps(qs.query))
+ self.assertEqual(
+ reloaded.get(),
+ {"name": "test", "latest_time": self.happening.when},
+ )
+
+ def test_annotation_values_list(self):
+ # values_list() is reloaded to values() when using a pickled query.
+ tests = [
+ Happening.objects.values_list("name"),
+ Happening.objects.values_list("name", flat=True),
+ Happening.objects.values_list("name", named=True),
+ ]
+ for qs in tests:
+ with self.subTest(qs._iterable_class.__name__):
+ reloaded = Happening.objects.all()
+ reloaded.query = pickle.loads(pickle.dumps(qs.query))
+ self.assertEqual(reloaded.get(), {"name": "test"})
+
+ def test_filter_deferred(self):
+ qs = Happening.objects.all()
+ qs._defer_next_filter = True
+ qs = qs.filter(id=0)
+ self.assert_pickles(qs)
+
+ def test_missing_django_version_unpickling(self):
+ """
+ #21430 -- Verifies a warning is raised for querysets that are
+ unpickled without a Django version
+ """
+ qs = Group.missing_django_version_objects.all()
+ msg = "Pickled queryset instance's Django version is not specified."
+ with self.assertRaisesMessage(RuntimeWarning, msg):
+ pickle.loads(pickle.dumps(qs))
+
+ def test_unsupported_unpickle(self):
+ """
+ #21430 -- Verifies a warning is raised for querysets that are
+ unpickled with a different Django version than the current
+ """
+ qs = Group.previous_django_version_objects.all()
+ msg = (
+ "Pickled queryset instance's Django version 1.0 does not match "
+ "the current version %s." % django.__version__
+ )
+ with self.assertRaisesMessage(RuntimeWarning, msg):
+ pickle.loads(pickle.dumps(qs))
+
+ def test_order_by_model_with_abstract_inheritance_and_meta_ordering(self):
+ group = Group.objects.create(name="test")
+ event = MyEvent.objects.create(title="test event", group=group)
+ event.edition_set.create()
+ self.assert_pickles(event.edition_set.order_by("event"))
+
+
+class InLookupTests(TestCase):
+ @classmethod
+ def setUpTestData(cls):
+ for i in range(1, 3):
+ group = Group.objects.create(name="Group {}".format(i))
+ cls.e1 = Event.objects.create(title="Event 1", group=group)
+
+ def test_in_lookup_queryset_evaluation(self):
+ """
+ Neither pickling nor unpickling a QuerySet.query with an __in=inner_qs
+ lookup should evaluate inner_qs.
+ """
+ events = Event.objects.filter(group__in=Group.objects.all())
+
+ with self.assertNumQueries(0):
+ dumped = pickle.dumps(events.query)
+
+ with self.assertNumQueries(0):
+ reloaded = pickle.loads(dumped)
+ reloaded_events = Event.objects.none()
+ reloaded_events.query = reloaded
+
+ self.assertSequenceEqual(reloaded_events, [self.e1])
+
+ def test_in_lookup_query_evaluation(self):
+ events = Event.objects.filter(group__in=Group.objects.values("id").query)
+
+ with self.assertNumQueries(0):
+ dumped = pickle.dumps(events.query)
+
+ with self.assertNumQueries(0):
+ reloaded = pickle.loads(dumped)
+ reloaded_events = Event.objects.none()
+ reloaded_events.query = reloaded
+
+ self.assertSequenceEqual(reloaded_events, [self.e1])
diff --git a/testbed/django__django/tests/raw_query/__init__.py b/testbed/django__django/tests/raw_query/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testbed/django__django/tests/raw_query/tests.py b/testbed/django__django/tests/raw_query/tests.py
new file mode 100644
index 0000000000000000000000000000000000000000..1dcc7ce7407dd177fc048019452ea7eaaf94e2b0
--- /dev/null
+++ b/testbed/django__django/tests/raw_query/tests.py
@@ -0,0 +1,419 @@
+from datetime import date
+from decimal import Decimal
+
+from django.core.exceptions import FieldDoesNotExist
+from django.db.models.query import RawQuerySet
+from django.test import TestCase, skipUnlessDBFeature
+
+from .models import (
+ Author,
+ Book,
+ BookFkAsPk,
+ Coffee,
+ FriendlyAuthor,
+ MixedCaseIDColumn,
+ Reviewer,
+)
+
+
+class RawQueryTests(TestCase):
+ @classmethod
+ def setUpTestData(cls):
+ cls.a1 = Author.objects.create(
+ first_name="Joe", last_name="Smith", dob=date(1950, 9, 20)
+ )
+ cls.a2 = Author.objects.create(
+ first_name="Jill", last_name="Doe", dob=date(1920, 4, 2)
+ )
+ cls.a3 = Author.objects.create(
+ first_name="Bob", last_name="Smith", dob=date(1986, 1, 25)
+ )
+ cls.a4 = Author.objects.create(
+ first_name="Bill", last_name="Jones", dob=date(1932, 5, 10)
+ )
+ cls.b1 = Book.objects.create(
+ title="The awesome book",
+ author=cls.a1,
+ paperback=False,
+ opening_line=(
+ "It was a bright cold day in April and the clocks were striking "
+ "thirteen."
+ ),
+ )
+ cls.b2 = Book.objects.create(
+ title="The horrible book",
+ author=cls.a1,
+ paperback=True,
+ opening_line=(
+ "On an evening in the latter part of May a middle-aged man "
+ "was walking homeward from Shaston to the village of Marlott, "
+ "in the adjoining Vale of Blakemore, or Blackmoor."
+ ),
+ )
+ cls.b3 = Book.objects.create(
+ title="Another awesome book",
+ author=cls.a1,
+ paperback=False,
+ opening_line="A squat gray building of only thirty-four stories.",
+ )
+ cls.b4 = Book.objects.create(
+ title="Some other book",
+ author=cls.a3,
+ paperback=True,
+ opening_line="It was the day my grandmother exploded.",
+ )
+ cls.c1 = Coffee.objects.create(brand="dunkin doughnuts")
+ cls.c2 = Coffee.objects.create(brand="starbucks")
+ cls.r1 = Reviewer.objects.create()
+ cls.r2 = Reviewer.objects.create()
+ cls.r1.reviewed.add(cls.b2, cls.b3, cls.b4)
+
+ def assertSuccessfulRawQuery(
+ self,
+ model,
+ query,
+ expected_results,
+ expected_annotations=(),
+ params=[],
+ translations=None,
+ ):
+ """
+ Execute the passed query against the passed model and check the output
+ """
+ results = list(
+ model.objects.raw(query, params=params, translations=translations)
+ )
+ self.assertProcessed(model, results, expected_results, expected_annotations)
+ self.assertAnnotations(results, expected_annotations)
+
+ def assertProcessed(self, model, results, orig, expected_annotations=()):
+ """
+ Compare the results of a raw query against expected results
+ """
+ self.assertEqual(len(results), len(orig))
+ for index, item in enumerate(results):
+ orig_item = orig[index]
+ for annotation in expected_annotations:
+ setattr(orig_item, *annotation)
+
+ for field in model._meta.fields:
+ # All values on the model are equal
+ self.assertEqual(
+ getattr(item, field.attname), getattr(orig_item, field.attname)
+ )
+ # This includes checking that they are the same type
+ self.assertEqual(
+ type(getattr(item, field.attname)),
+ type(getattr(orig_item, field.attname)),
+ )
+
+ def assertNoAnnotations(self, results):
+ """
+ The results of a raw query contain no annotations
+ """
+ self.assertAnnotations(results, ())
+
+ def assertAnnotations(self, results, expected_annotations):
+ """
+ The passed raw query results contain the expected annotations
+ """
+ if expected_annotations:
+ for index, result in enumerate(results):
+ annotation, value = expected_annotations[index]
+ self.assertTrue(hasattr(result, annotation))
+ self.assertEqual(getattr(result, annotation), value)
+
+ def test_rawqueryset_repr(self):
+ queryset = RawQuerySet(raw_query="SELECT * FROM raw_query_author")
+ self.assertEqual(
+ repr(queryset), ""
+ )
+ self.assertEqual(
+ repr(queryset.query), ""
+ )
+
+ def test_simple_raw_query(self):
+ """
+ Basic test of raw query with a simple database query
+ """
+ query = "SELECT * FROM raw_query_author"
+ authors = Author.objects.all()
+ self.assertSuccessfulRawQuery(Author, query, authors)
+
+ def test_raw_query_lazy(self):
+ """
+ Raw queries are lazy: they aren't actually executed until they're
+ iterated over.
+ """
+ q = Author.objects.raw("SELECT * FROM raw_query_author")
+ self.assertIsNone(q.query.cursor)
+ list(q)
+ self.assertIsNotNone(q.query.cursor)
+
+ def test_FK_raw_query(self):
+ """
+ Test of a simple raw query against a model containing a foreign key
+ """
+ query = "SELECT * FROM raw_query_book"
+ books = Book.objects.all()
+ self.assertSuccessfulRawQuery(Book, query, books)
+
+ def test_db_column_handler(self):
+ """
+ Test of a simple raw query against a model containing a field with
+ db_column defined.
+ """
+ query = "SELECT * FROM raw_query_coffee"
+ coffees = Coffee.objects.all()
+ self.assertSuccessfulRawQuery(Coffee, query, coffees)
+
+ def test_pk_with_mixed_case_db_column(self):
+ """
+ A raw query with a model that has a pk db_column with mixed case.
+ """
+ query = "SELECT * FROM raw_query_mixedcaseidcolumn"
+ queryset = MixedCaseIDColumn.objects.all()
+ self.assertSuccessfulRawQuery(MixedCaseIDColumn, query, queryset)
+
+ def test_order_handler(self):
+ """
+ Test of raw raw query's tolerance for columns being returned in any
+ order
+ """
+ selects = (
+ ("dob, last_name, first_name, id"),
+ ("last_name, dob, first_name, id"),
+ ("first_name, last_name, dob, id"),
+ )
+
+ for select in selects:
+ query = "SELECT %s FROM raw_query_author" % select
+ authors = Author.objects.all()
+ self.assertSuccessfulRawQuery(Author, query, authors)
+
+ def test_translations(self):
+ """
+ Test of raw query's optional ability to translate unexpected result
+ column names to specific model fields
+ """
+ query = (
+ "SELECT first_name AS first, last_name AS last, dob, id "
+ "FROM raw_query_author"
+ )
+ translations = {"first": "first_name", "last": "last_name"}
+ authors = Author.objects.all()
+ self.assertSuccessfulRawQuery(Author, query, authors, translations=translations)
+
+ def test_params(self):
+ """
+ Test passing optional query parameters
+ """
+ query = "SELECT * FROM raw_query_author WHERE first_name = %s"
+ author = Author.objects.all()[2]
+ params = [author.first_name]
+ qset = Author.objects.raw(query, params=params)
+ results = list(qset)
+ self.assertProcessed(Author, results, [author])
+ self.assertNoAnnotations(results)
+ self.assertEqual(len(results), 1)
+ self.assertIsInstance(repr(qset), str)
+
+ def test_params_none(self):
+ query = "SELECT * FROM raw_query_author WHERE first_name like 'J%'"
+ qset = Author.objects.raw(query, params=None)
+ self.assertEqual(len(qset), 2)
+
+ def test_escaped_percent(self):
+ query = "SELECT * FROM raw_query_author WHERE first_name like 'J%%'"
+ qset = Author.objects.raw(query)
+ self.assertEqual(len(qset), 2)
+
+ @skipUnlessDBFeature("supports_paramstyle_pyformat")
+ def test_pyformat_params(self):
+ """
+ Test passing optional query parameters
+ """
+ query = "SELECT * FROM raw_query_author WHERE first_name = %(first)s"
+ author = Author.objects.all()[2]
+ params = {"first": author.first_name}
+ qset = Author.objects.raw(query, params=params)
+ results = list(qset)
+ self.assertProcessed(Author, results, [author])
+ self.assertNoAnnotations(results)
+ self.assertEqual(len(results), 1)
+ self.assertIsInstance(repr(qset), str)
+
+ def test_query_representation(self):
+ """
+ Test representation of raw query with parameters
+ """
+ query = "SELECT * FROM raw_query_author WHERE last_name = %(last)s"
+ qset = Author.objects.raw(query, {"last": "foo"})
+ self.assertEqual(
+ repr(qset),
+ "",
+ )
+ self.assertEqual(
+ repr(qset.query),
+ "",
+ )
+
+ query = "SELECT * FROM raw_query_author WHERE last_name = %s"
+ qset = Author.objects.raw(query, {"foo"})
+ self.assertEqual(
+ repr(qset),
+ "",
+ )
+ self.assertEqual(
+ repr(qset.query),
+ "",
+ )
+
+ def test_many_to_many(self):
+ """
+ Test of a simple raw query against a model containing a m2m field
+ """
+ query = "SELECT * FROM raw_query_reviewer"
+ reviewers = Reviewer.objects.all()
+ self.assertSuccessfulRawQuery(Reviewer, query, reviewers)
+
+ def test_extra_conversions(self):
+ """Extra translations are ignored."""
+ query = "SELECT * FROM raw_query_author"
+ translations = {"something": "else"}
+ authors = Author.objects.all()
+ self.assertSuccessfulRawQuery(Author, query, authors, translations=translations)
+
+ def test_missing_fields(self):
+ query = "SELECT id, first_name, dob FROM raw_query_author"
+ for author in Author.objects.raw(query):
+ self.assertIsNotNone(author.first_name)
+ # last_name isn't given, but it will be retrieved on demand
+ self.assertIsNotNone(author.last_name)
+
+ def test_missing_fields_without_PK(self):
+ query = "SELECT first_name, dob FROM raw_query_author"
+ msg = "Raw query must include the primary key"
+ with self.assertRaisesMessage(FieldDoesNotExist, msg):
+ list(Author.objects.raw(query))
+
+ def test_annotations(self):
+ query = (
+ "SELECT a.*, count(b.id) as book_count "
+ "FROM raw_query_author a "
+ "LEFT JOIN raw_query_book b ON a.id = b.author_id "
+ "GROUP BY a.id, a.first_name, a.last_name, a.dob ORDER BY a.id"
+ )
+ expected_annotations = (
+ ("book_count", 3),
+ ("book_count", 0),
+ ("book_count", 1),
+ ("book_count", 0),
+ )
+ authors = Author.objects.order_by("pk")
+ self.assertSuccessfulRawQuery(Author, query, authors, expected_annotations)
+
+ def test_white_space_query(self):
+ query = " SELECT * FROM raw_query_author"
+ authors = Author.objects.all()
+ self.assertSuccessfulRawQuery(Author, query, authors)
+
+ def test_multiple_iterations(self):
+ query = "SELECT * FROM raw_query_author"
+ normal_authors = Author.objects.all()
+ raw_authors = Author.objects.raw(query)
+
+ # First Iteration
+ first_iterations = 0
+ for index, raw_author in enumerate(raw_authors):
+ self.assertEqual(normal_authors[index], raw_author)
+ first_iterations += 1
+
+ # Second Iteration
+ second_iterations = 0
+ for index, raw_author in enumerate(raw_authors):
+ self.assertEqual(normal_authors[index], raw_author)
+ second_iterations += 1
+
+ self.assertEqual(first_iterations, second_iterations)
+
+ def test_get_item(self):
+ # Indexing on RawQuerySets
+ query = "SELECT * FROM raw_query_author ORDER BY id ASC"
+ third_author = Author.objects.raw(query)[2]
+ self.assertEqual(third_author.first_name, "Bob")
+
+ first_two = Author.objects.raw(query)[0:2]
+ self.assertEqual(len(first_two), 2)
+
+ with self.assertRaises(TypeError):
+ Author.objects.raw(query)["test"]
+
+ def test_inheritance(self):
+ f = FriendlyAuthor.objects.create(
+ first_name="Wesley", last_name="Chun", dob=date(1962, 10, 28)
+ )
+ query = "SELECT * FROM raw_query_friendlyauthor"
+ self.assertEqual([o.pk for o in FriendlyAuthor.objects.raw(query)], [f.pk])
+
+ def test_query_count(self):
+ self.assertNumQueries(
+ 1, list, Author.objects.raw("SELECT * FROM raw_query_author")
+ )
+
+ def test_subquery_in_raw_sql(self):
+ list(
+ Book.objects.raw(
+ "SELECT id FROM "
+ "(SELECT * FROM raw_query_book WHERE paperback IS NOT NULL) sq"
+ )
+ )
+
+ def test_db_column_name_is_used_in_raw_query(self):
+ """
+ Regression test that ensures the `column` attribute on the field is
+ used to generate the list of fields included in the query, as opposed
+ to the `attname`. This is important when the primary key is a
+ ForeignKey field because `attname` and `column` are not necessarily the
+ same.
+ """
+ b = BookFkAsPk.objects.create(book=self.b1)
+ self.assertEqual(
+ list(
+ BookFkAsPk.objects.raw(
+ "SELECT not_the_default FROM raw_query_bookfkaspk"
+ )
+ ),
+ [b],
+ )
+
+ def test_decimal_parameter(self):
+ c = Coffee.objects.create(brand="starbucks", price=20.5)
+ qs = Coffee.objects.raw(
+ "SELECT * FROM raw_query_coffee WHERE price >= %s", params=[Decimal(20)]
+ )
+ self.assertEqual(list(qs), [c])
+
+ def test_result_caching(self):
+ with self.assertNumQueries(1):
+ books = Book.objects.raw("SELECT * FROM raw_query_book")
+ list(books)
+ list(books)
+
+ def test_iterator(self):
+ with self.assertNumQueries(2):
+ books = Book.objects.raw("SELECT * FROM raw_query_book")
+ list(books.iterator())
+ list(books.iterator())
+
+ def test_bool(self):
+ self.assertIs(bool(Book.objects.raw("SELECT * FROM raw_query_book")), True)
+ self.assertIs(
+ bool(Book.objects.raw("SELECT * FROM raw_query_book WHERE id = 0")), False
+ )
+
+ def test_len(self):
+ self.assertEqual(len(Book.objects.raw("SELECT * FROM raw_query_book")), 4)
+ self.assertEqual(
+ len(Book.objects.raw("SELECT * FROM raw_query_book WHERE id = 0")), 0
+ )
diff --git a/testbed/django__django/tests/redirects_tests/__init__.py b/testbed/django__django/tests/redirects_tests/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testbed/django__django/tests/redirects_tests/tests.py b/testbed/django__django/tests/redirects_tests/tests.py
new file mode 100644
index 0000000000000000000000000000000000000000..d175be62fb6123a36874e3e3266c60816c19d3b5
--- /dev/null
+++ b/testbed/django__django/tests/redirects_tests/tests.py
@@ -0,0 +1,114 @@
+from django.conf import settings
+from django.contrib.redirects.middleware import RedirectFallbackMiddleware
+from django.contrib.redirects.models import Redirect
+from django.contrib.sites.models import Site
+from django.core.exceptions import ImproperlyConfigured
+from django.http import HttpResponse, HttpResponseForbidden, HttpResponseRedirect
+from django.test import TestCase, modify_settings, override_settings
+
+
+@modify_settings(
+ MIDDLEWARE={
+ "append": "django.contrib.redirects.middleware.RedirectFallbackMiddleware"
+ }
+)
+@override_settings(APPEND_SLASH=False, ROOT_URLCONF="redirects_tests.urls", SITE_ID=1)
+class RedirectTests(TestCase):
+ @classmethod
+ def setUpTestData(cls):
+ cls.site = Site.objects.get(pk=settings.SITE_ID)
+
+ def test_model(self):
+ r1 = Redirect.objects.create(
+ site=self.site, old_path="/initial", new_path="/new_target"
+ )
+ self.assertEqual(str(r1), "/initial ---> /new_target")
+
+ def test_redirect(self):
+ Redirect.objects.create(
+ site=self.site, old_path="/initial", new_path="/new_target"
+ )
+ response = self.client.get("/initial")
+ self.assertRedirects(
+ response, "/new_target", status_code=301, target_status_code=404
+ )
+
+ @override_settings(APPEND_SLASH=True)
+ def test_redirect_with_append_slash(self):
+ Redirect.objects.create(
+ site=self.site, old_path="/initial/", new_path="/new_target/"
+ )
+ response = self.client.get("/initial")
+ self.assertRedirects(
+ response, "/new_target/", status_code=301, target_status_code=404
+ )
+
+ @override_settings(APPEND_SLASH=True)
+ def test_redirect_with_append_slash_and_query_string(self):
+ Redirect.objects.create(
+ site=self.site, old_path="/initial/?foo", new_path="/new_target/"
+ )
+ response = self.client.get("/initial?foo")
+ self.assertRedirects(
+ response, "/new_target/", status_code=301, target_status_code=404
+ )
+
+ @override_settings(APPEND_SLASH=True)
+ def test_redirect_not_found_with_append_slash(self):
+ """
+ Exercise the second Redirect.DoesNotExist branch in
+ RedirectFallbackMiddleware.
+ """
+ response = self.client.get("/test")
+ self.assertEqual(response.status_code, 404)
+
+ def test_redirect_shortcircuits_non_404_response(self):
+ """RedirectFallbackMiddleware short-circuits on non-404 requests."""
+ response = self.client.get("/")
+ self.assertEqual(response.status_code, 200)
+
+ def test_response_gone(self):
+ """When the redirect target is '', return a 410"""
+ Redirect.objects.create(site=self.site, old_path="/initial", new_path="")
+ response = self.client.get("/initial")
+ self.assertEqual(response.status_code, 410)
+
+ @modify_settings(INSTALLED_APPS={"remove": "django.contrib.sites"})
+ def test_sites_not_installed(self):
+ def get_response(request):
+ return HttpResponse()
+
+ msg = (
+ "You cannot use RedirectFallbackMiddleware when "
+ "django.contrib.sites is not installed."
+ )
+ with self.assertRaisesMessage(ImproperlyConfigured, msg):
+ RedirectFallbackMiddleware(get_response)
+
+
+class OverriddenRedirectFallbackMiddleware(RedirectFallbackMiddleware):
+ # Use HTTP responses different from the defaults
+ response_gone_class = HttpResponseForbidden
+ response_redirect_class = HttpResponseRedirect
+
+
+@modify_settings(
+ MIDDLEWARE={"append": "redirects_tests.tests.OverriddenRedirectFallbackMiddleware"}
+)
+@override_settings(SITE_ID=1)
+class OverriddenRedirectMiddlewareTests(TestCase):
+ @classmethod
+ def setUpTestData(cls):
+ cls.site = Site.objects.get(pk=settings.SITE_ID)
+
+ def test_response_gone_class(self):
+ Redirect.objects.create(site=self.site, old_path="/initial/", new_path="")
+ response = self.client.get("/initial/")
+ self.assertEqual(response.status_code, 403)
+
+ def test_response_redirect_class(self):
+ Redirect.objects.create(
+ site=self.site, old_path="/initial/", new_path="/new_target/"
+ )
+ response = self.client.get("/initial/")
+ self.assertEqual(response.status_code, 302)
diff --git a/testbed/django__django/tests/redirects_tests/urls.py b/testbed/django__django/tests/redirects_tests/urls.py
new file mode 100644
index 0000000000000000000000000000000000000000..0b17a91504573489e4a990b0a801fbb90f3b7e66
--- /dev/null
+++ b/testbed/django__django/tests/redirects_tests/urls.py
@@ -0,0 +1,6 @@
+from django.http import HttpResponse
+from django.urls import path
+
+urlpatterns = [
+ path("", lambda req: HttpResponse("OK")),
+]
diff --git a/testbed/django__django/tests/requirements/postgres.txt b/testbed/django__django/tests/requirements/postgres.txt
new file mode 100644
index 0000000000000000000000000000000000000000..da007293194a5eb1824d80ef7ac99ed4a677544f
--- /dev/null
+++ b/testbed/django__django/tests/requirements/postgres.txt
@@ -0,0 +1 @@
+psycopg[binary]>=3.1.8
diff --git a/testbed/django__django/tests/reserved_names/__init__.py b/testbed/django__django/tests/reserved_names/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/testbed/django__django/tests/reserved_names/models.py b/testbed/django__django/tests/reserved_names/models.py
new file mode 100644
index 0000000000000000000000000000000000000000..0d763736035f21524cf58e6b09b6344f8f4092f2
--- /dev/null
+++ b/testbed/django__django/tests/reserved_names/models.py
@@ -0,0 +1,27 @@
+"""
+Using SQL reserved names
+
+Need to use a reserved SQL name as a column name or table name? Need to include
+a hyphen in a column or table name? No problem. Django quotes names
+appropriately behind the scenes, so your database won't complain about
+reserved-name usage.
+"""
+
+from django.db import models
+
+
+class Thing(models.Model):
+ when = models.CharField(max_length=1, primary_key=True)
+ join = models.CharField(max_length=1)
+ like = models.CharField(max_length=1)
+ drop = models.CharField(max_length=1)
+ alter = models.CharField(max_length=1)
+ having = models.CharField(max_length=1)
+ where = models.DateField(max_length=1)
+ has_hyphen = models.CharField(max_length=1, db_column="has-hyphen")
+
+ class Meta:
+ db_table = "select"
+
+ def __str__(self):
+ return self.when
diff --git a/testbed/django__django/tests/resolve_url/__init__.py b/testbed/django__django/tests/resolve_url/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391