diff options
39 files changed, 1450 insertions, 1804 deletions
diff --git a/django/test/testcases.py b/django/test/testcases.py index 05cce99c3a..716eef5e42 100644 --- a/django/test/testcases.py +++ b/django/test/testcases.py @@ -1040,11 +1040,29 @@ class TransactionTestCase(SimpleTestCase): allow_cascade=self.available_apps is not None, inhibit_post_migrate=inhibit_post_migrate) - def assertQuerysetEqual(self, qs, values, transform=repr, ordered=True, msg=None): - items = map(transform, qs) + def assertQuerysetEqual(self, qs, values, transform=None, ordered=True, msg=None): + values = list(values) + # RemovedInDjango41Warning. + if transform is None: + if ( + values and isinstance(values[0], str) and + qs and not isinstance(qs[0], str) + ): + # Transform qs using repr() if the first element of values is a + # string and the first element of qs is not (which would be the + # case if qs is a flattened values_list). + warnings.warn( + "In Django 4.1, repr() will not be called automatically " + "on a queryset when compared to string values. Set an " + "explicit 'transform' to silence this warning.", + category=RemovedInDjango41Warning, + ) + transform = repr + items = qs + if transform is not None: + items = map(transform, items) if not ordered: return self.assertEqual(Counter(items), Counter(values), msg=msg) - values = list(values) # For example qs.iterator() could be passed as qs, but it does not # have 'ordered' attribute. if len(values) > 1 and hasattr(qs, 'ordered') and not qs.ordered: diff --git a/docs/internals/deprecation.txt b/docs/internals/deprecation.txt index 46a1aaaee6..06ea0fbbc0 100644 --- a/docs/internals/deprecation.txt +++ b/docs/internals/deprecation.txt @@ -26,6 +26,9 @@ details on these changes. * The ``default_app_config`` module variable will be removed. +* ``TransactionTestCase.assertQuerysetEqual()` will no longer automatically + call ``repr()`` on a queryset when compared to string values. + .. _deprecation-removed-in-4.0: 4.0 diff --git a/docs/intro/tutorial05.txt b/docs/intro/tutorial05.txt index 046abb8124..1ff868b1cb 100644 --- a/docs/intro/tutorial05.txt +++ b/docs/intro/tutorial05.txt @@ -498,11 +498,11 @@ class: Questions with a pub_date in the past are displayed on the index page. """ - create_question(question_text="Past question.", days=-30) + question = create_question(question_text="Past question.", days=-30) response = self.client.get(reverse('polls:index')) self.assertQuerysetEqual( response.context['latest_question_list'], - ['<Question: Past question.>'] + [question], ) def test_future_question(self): @@ -520,24 +520,24 @@ class: Even if both past and future questions exist, only past questions are displayed. """ - create_question(question_text="Past question.", days=-30) + question = create_question(question_text="Past question.", days=-30) create_question(question_text="Future question.", days=30) response = self.client.get(reverse('polls:index')) self.assertQuerysetEqual( response.context['latest_question_list'], - ['<Question: Past question.>'] + [question], ) def test_two_past_questions(self): """ The questions index page may display multiple questions. """ - create_question(question_text="Past question 1.", days=-30) - create_question(question_text="Past question 2.", days=-5) + question1 = create_question(question_text="Past question 1.", days=-30) + question2 = create_question(question_text="Past question 2.", days=-5) response = self.client.get(reverse('polls:index')) self.assertQuerysetEqual( response.context['latest_question_list'], - ['<Question: Past question 2.>', '<Question: Past question 1.>'] + [question2, question1], ) diff --git a/docs/releases/3.2.txt b/docs/releases/3.2.txt index a460f96eef..f542a4fee9 100644 --- a/docs/releases/3.2.txt +++ b/docs/releases/3.2.txt @@ -422,6 +422,11 @@ Tests <django.db.transaction.on_commit>` in a list. This allows you to test such callbacks without using the slower :class:`.TransactionTestCase`. +* :meth:`.TransactionTestCase.assertQuerysetEqual` now supports direct + comparison against another queryset rather than being restricted to + comparison against a list of string representations of objects when using the + default value for the ``transform`` argument. + URLs ~~~~ @@ -615,3 +620,8 @@ Miscellaneous * The ``default_app_config`` application configuration variable is deprecated, due to the now automatic ``AppConfig`` discovery. See :ref:`whats-new-3.2` for more details. + +* Automatically calling ``repr()`` on a queryset in + ``TransactionTestCase.assertQuerysetEqual()``, when compared to string + values, is deprecated. If you need the previous behavior, explicitly set + ``transform`` to ``repr``. diff --git a/docs/topics/testing/tools.txt b/docs/topics/testing/tools.txt index 2d10873611..678eb260aa 100644 --- a/docs/topics/testing/tools.txt +++ b/docs/topics/testing/tools.txt @@ -1683,15 +1683,13 @@ your test suite. Output in case of error can be customized with the ``msg`` argument. -.. method:: TransactionTestCase.assertQuerysetEqual(qs, values, transform=repr, ordered=True, msg=None) +.. method:: TransactionTestCase.assertQuerysetEqual(qs, values, transform=None, ordered=True, msg=None) - Asserts that a queryset ``qs`` returns a particular list of values ``values``. + Asserts that a queryset ``qs`` matches a particular iterable of values + ``values``. - The comparison of the contents of ``qs`` and ``values`` is performed by - applying ``transform`` to ``qs``. By default, this means that the - ``repr()`` of each value in ``qs`` is compared to the ``values``. Any other - callable can be used if ``repr()`` doesn't provide a unique or helpful - comparison. + If ``transform`` is provided, ``values`` is compared to a list produced by + applying ``transform`` to each member of ``qs``. By default, the comparison is also ordering dependent. If ``qs`` doesn't provide an implicit ordering, you can set the ``ordered`` parameter to @@ -1702,6 +1700,21 @@ your test suite. Output in case of error can be customized with the ``msg`` argument. + .. versionchanged:: 3.2 + + The default value of ``transform`` argument was changed to ``None``. + + .. versionadded:: 3.2 + + Support for direct comparison between querysets was added. + + .. deprecated:: 3.2 + + If ``transform`` is not provided and ``values`` is a list of strings, + it's compared to a list produced by applying ``repr()`` to each member + of ``qs``. This behavior is deprecated and will be removed in Django + 4.1. If you need it, explicitly set ``transform`` to ``repr``. + .. method:: TransactionTestCase.assertNumQueries(num, func, *args, **kwargs) Asserts that when ``func`` is called with ``*args`` and ``**kwargs`` that diff --git a/tests/aggregation/tests.py b/tests/aggregation/tests.py index 62704c4bd2..43fd9dd074 100644 --- a/tests/aggregation/tests.py +++ b/tests/aggregation/tests.py @@ -750,13 +750,13 @@ class AggregateTestCase(TestCase): number of authors. """ dates = Book.objects.annotate(num_authors=Count("authors")).dates('pubdate', 'year') - self.assertQuerysetEqual( + self.assertSequenceEqual( dates, [ - "datetime.date(1991, 1, 1)", - "datetime.date(1995, 1, 1)", - "datetime.date(2007, 1, 1)", - "datetime.date(2008, 1, 1)" - ] + datetime.date(1991, 1, 1), + datetime.date(1995, 1, 1), + datetime.date(2007, 1, 1), + datetime.date(2008, 1, 1), + ], ) def test_values_aggregation(self): diff --git a/tests/basic/tests.py b/tests/basic/tests.py index 173458f5ff..43c7ccdfa6 100644 --- a/tests/basic/tests.py +++ b/tests/basic/tests.py @@ -161,13 +161,11 @@ class ModelTest(TestCase): Article(headline=headline, pub_date=some_pub_date).save() self.assertQuerysetEqual( Article.objects.all().order_by('headline'), - ["<Article: Amazing article>", - "<Article: An article>", - "<Article: Article One>", - "<Article: Boring article>"] + sorted(headlines), + transform=lambda a: a.headline, ) Article.objects.filter(headline__startswith='A').delete() - self.assertQuerysetEqual(Article.objects.all().order_by('headline'), ["<Article: Boring article>"]) + self.assertEqual(Article.objects.get().headline, 'Boring article') def test_not_equal_and_equal_operators_behave_as_expected_on_instances(self): some_pub_date = datetime(2014, 5, 16, 12, 1) @@ -208,17 +206,17 @@ class ModelTest(TestCase): def test_year_lookup_edge_case(self): # Edge-case test: A year lookup should retrieve all objects in # the given year, including Jan. 1 and Dec. 31. - Article.objects.create( + a11 = Article.objects.create( headline='Article 11', pub_date=datetime(2008, 1, 1), ) - Article.objects.create( + a12 = Article.objects.create( headline='Article 12', pub_date=datetime(2008, 12, 31, 23, 59, 59, 999999), ) - self.assertQuerysetEqual( + self.assertSequenceEqual( Article.objects.filter(pub_date__year=2008), - ["<Article: Article 11>", "<Article: Article 12>"] + [a11, a12], ) def test_unicode_data(self): @@ -442,7 +440,7 @@ class ModelLookupTest(TestCase): self.a.save() # Article.objects.all() returns all the articles in the database. - self.assertQuerysetEqual(Article.objects.all(), ['<Article: Parrot programs in Python>']) + self.assertSequenceEqual(Article.objects.all(), [self.a]) def test_rich_lookup(self): # Django provides a rich database lookup API. @@ -458,24 +456,24 @@ class ModelLookupTest(TestCase): self.assertEqual(Article.objects.get(id=self.a.id), self.a) self.assertEqual(Article.objects.get(headline='Swallow programs in Python'), self.a) - self.assertQuerysetEqual( + self.assertSequenceEqual( Article.objects.filter(pub_date__year=2005), - ['<Article: Swallow programs in Python>'], + [self.a], ) - self.assertQuerysetEqual( + self.assertSequenceEqual( Article.objects.filter(pub_date__year=2004), [], ) - self.assertQuerysetEqual( + self.assertSequenceEqual( Article.objects.filter(pub_date__year=2005, pub_date__month=7), - ['<Article: Swallow programs in Python>'], + [self.a], ) - self.assertQuerysetEqual( + self.assertSequenceEqual( Article.objects.filter(pub_date__week_day=5), - ['<Article: Swallow programs in Python>'], + [self.a], ) - self.assertQuerysetEqual( + self.assertSequenceEqual( Article.objects.filter(pub_date__week_day=6), [], ) @@ -499,7 +497,7 @@ class ModelLookupTest(TestCase): self.assertEqual(Article.objects.get(pk=self.a.id), self.a) # pk can be used as a shortcut for the primary key name in any query. - self.assertQuerysetEqual(Article.objects.filter(pk__in=[self.a.id]), ["<Article: Swallow programs in Python>"]) + self.assertSequenceEqual(Article.objects.filter(pk__in=[self.a.id]), [self.a]) # Model instances of the same type and same ID are considered equal. a = Article.objects.get(pk=self.a.id) diff --git a/tests/custom_columns/tests.py b/tests/custom_columns/tests.py index 874b024050..b389a7e02f 100644 --- a/tests/custom_columns/tests.py +++ b/tests/custom_columns/tests.py @@ -78,15 +78,15 @@ class CustomColumnsTests(TestCase): ) def test_author_querying(self): - self.assertQuerysetEqual( + self.assertSequenceEqual( Author.objects.all().order_by('last_name'), - ['<Author: Peter Jones>', '<Author: John Smith>'] + [self.a2, self.a1], ) def test_author_filtering(self): - self.assertQuerysetEqual( + self.assertSequenceEqual( Author.objects.filter(first_name__exact='John'), - ['<Author: John Smith>'] + [self.a1], ) def test_author_get(self): @@ -111,15 +111,12 @@ class CustomColumnsTests(TestCase): getattr(a, 'last') def test_m2m_table(self): - self.assertQuerysetEqual( + self.assertSequenceEqual( self.article.authors.all().order_by('last_name'), - ['<Author: Peter Jones>', '<Author: John Smith>'] + [self.a2, self.a1], ) - self.assertQuerysetEqual( - self.a1.article_set.all(), - ['<Article: Django lets you build Web apps easily>'] - ) - self.assertQuerysetEqual( + self.assertSequenceEqual(self.a1.article_set.all(), [self.article]) + self.assertSequenceEqual( self.article.authors.filter(last_name='Jones'), - ['<Author: Peter Jones>'] + [self.a2], ) diff --git a/tests/custom_lookups/tests.py b/tests/custom_lookups/tests.py index 14f95a241b..1be4de790d 100644 --- a/tests/custom_lookups/tests.py +++ b/tests/custom_lookups/tests.py @@ -308,17 +308,17 @@ class BilateralTransformTests(TestCase): def test_bilateral_upper(self): with register_lookup(models.CharField, UpperBilateralTransform): - Author.objects.bulk_create([ - Author(name='Doe'), - Author(name='doe'), - Author(name='Foo'), - ]) - self.assertQuerysetEqual( + author1 = Author.objects.create(name='Doe') + author2 = Author.objects.create(name='doe') + author3 = Author.objects.create(name='Foo') + self.assertCountEqual( Author.objects.filter(name__upper='doe'), - ["<Author: Doe>", "<Author: doe>"], ordered=False) - self.assertQuerysetEqual( + [author1, author2], + ) + self.assertSequenceEqual( Author.objects.filter(name__upper__contains='f'), - ["<Author: Foo>"], ordered=False) + [author3], + ) def test_bilateral_inner_qs(self): with register_lookup(models.CharField, UpperBilateralTransform): diff --git a/tests/datetimes/tests.py b/tests/datetimes/tests.py index 857293acb6..f42936b557 100644 --- a/tests/datetimes/tests.py +++ b/tests/datetimes/tests.py @@ -134,33 +134,42 @@ class DateTimesTests(TestCase): for i, pub_date in enumerate(pub_dates): Article(pub_date=pub_date, title='title #{}'.format(i)).save() - self.assertQuerysetEqual( + self.assertSequenceEqual( Article.objects.datetimes('pub_date', 'year'), - ["datetime.datetime(2005, 1, 1, 0, 0)"]) - self.assertQuerysetEqual( + [datetime.datetime(2005, 1, 1, 0, 0)], + ) + self.assertSequenceEqual( Article.objects.datetimes('pub_date', 'month'), - ["datetime.datetime(2005, 7, 1, 0, 0)"]) - self.assertQuerysetEqual( + [datetime.datetime(2005, 7, 1, 0, 0)], + ) + self.assertSequenceEqual( Article.objects.datetimes('pub_date', 'week'), - ["datetime.datetime(2005, 7, 25, 0, 0)"]) - self.assertQuerysetEqual( - Article.objects.datetimes('pub_date', 'day'), - ["datetime.datetime(2005, 7, 28, 0, 0)", - "datetime.datetime(2005, 7, 29, 0, 0)", - "datetime.datetime(2005, 7, 30, 0, 0)", - "datetime.datetime(2005, 7, 31, 0, 0)"]) - self.assertQuerysetEqual( + [datetime.datetime(2005, 7, 25, 0, 0)], + ) + self.assertSequenceEqual(Article.objects.datetimes('pub_date', 'day'), [ + datetime.datetime(2005, 7, 28, 0, 0), + datetime.datetime(2005, 7, 29, 0, 0), + datetime.datetime(2005, 7, 30, 0, 0), + datetime.datetime(2005, 7, 31, 0, 0), + ]) + self.assertSequenceEqual( Article.objects.datetimes('pub_date', 'day', order='ASC'), - ["datetime.datetime(2005, 7, 28, 0, 0)", - "datetime.datetime(2005, 7, 29, 0, 0)", - "datetime.datetime(2005, 7, 30, 0, 0)", - "datetime.datetime(2005, 7, 31, 0, 0)"]) - self.assertQuerysetEqual( + [ + datetime.datetime(2005, 7, 28, 0, 0), + datetime.datetime(2005, 7, 29, 0, 0), + datetime.datetime(2005, 7, 30, 0, 0), + datetime.datetime(2005, 7, 31, 0, 0), + ], + ) + self.assertSequenceEqual( Article.objects.datetimes('pub_date', 'day', order='DESC'), - ["datetime.datetime(2005, 7, 31, 0, 0)", - "datetime.datetime(2005, 7, 30, 0, 0)", - "datetime.datetime(2005, 7, 29, 0, 0)", - "datetime.datetime(2005, 7, 28, 0, 0)"]) + [ + datetime.datetime(2005, 7, 31, 0, 0), + datetime.datetime(2005, 7, 30, 0, 0), + datetime.datetime(2005, 7, 29, 0, 0), + datetime.datetime(2005, 7, 28, 0, 0), + ], + ) def test_datetimes_has_lazy_iterator(self): pub_dates = [ diff --git a/tests/distinct_on_fields/tests.py b/tests/distinct_on_fields/tests.py index e19c3c1b65..34d4509cec 100644 --- a/tests/distinct_on_fields/tests.py +++ b/tests/distinct_on_fields/tests.py @@ -23,15 +23,15 @@ class DistinctOnTests(TestCase): cls.p3_o1 = Staff.objects.create(id=3, name="p3", organisation="o1") cls.p1_o2 = Staff.objects.create(id=4, name="p1", organisation="o2") cls.p1_o1.coworkers.add(cls.p2_o1, cls.p3_o1) - StaffTag.objects.create(staff=cls.p1_o1, tag=cls.t1) + cls.st1 = StaffTag.objects.create(staff=cls.p1_o1, tag=cls.t1) StaffTag.objects.create(staff=cls.p1_o1, tag=cls.t1) - celeb1 = Celebrity.objects.create(name="c1") - celeb2 = Celebrity.objects.create(name="c2") + cls.celeb1 = Celebrity.objects.create(name="c1") + cls.celeb2 = Celebrity.objects.create(name="c2") - cls.fan1 = Fan.objects.create(fan_of=celeb1) - cls.fan2 = Fan.objects.create(fan_of=celeb1) - cls.fan3 = Fan.objects.create(fan_of=celeb2) + cls.fan1 = Fan.objects.create(fan_of=cls.celeb1) + cls.fan2 = Fan.objects.create(fan_of=cls.celeb1) + cls.fan3 = Fan.objects.create(fan_of=cls.celeb2) def test_basic_distinct_on(self): """QuerySet.distinct('field', ...) works""" @@ -39,23 +39,23 @@ class DistinctOnTests(TestCase): qsets = ( ( Staff.objects.distinct().order_by('name'), - ['<Staff: p1>', '<Staff: p1>', '<Staff: p2>', '<Staff: p3>'], + [self.p1_o1, self.p1_o2, self.p2_o1, self.p3_o1], ), ( Staff.objects.distinct('name').order_by('name'), - ['<Staff: p1>', '<Staff: p2>', '<Staff: p3>'], + [self.p1_o1, self.p2_o1, self.p3_o1], ), ( Staff.objects.distinct('organisation').order_by('organisation', 'name'), - ['<Staff: p1>', '<Staff: p1>'], + [self.p1_o1, self.p1_o2], ), ( Staff.objects.distinct('name', 'organisation').order_by('name', 'organisation'), - ['<Staff: p1>', '<Staff: p1>', '<Staff: p2>', '<Staff: p3>'], + [self.p1_o1, self.p1_o2, self.p2_o1, self.p3_o1], ), ( Celebrity.objects.filter(fan__in=[self.fan1, self.fan2, self.fan3]).distinct('name').order_by('name'), - ['<Celebrity: c1>', '<Celebrity: c2>'], + [self.celeb1, self.celeb2], ), # Does combining querysets work? ( @@ -63,31 +63,28 @@ class DistinctOnTests(TestCase): distinct('name').order_by('name') | Celebrity.objects.filter(fan__in=[self.fan3]). distinct('name').order_by('name')), - ['<Celebrity: c1>', '<Celebrity: c2>'], - ), - ( - StaffTag.objects.distinct('staff', 'tag'), - ['<StaffTag: t1 -> p1>'], + [self.celeb1, self.celeb2], ), + (StaffTag.objects.distinct('staff', 'tag'), [self.st1]), ( Tag.objects.order_by('parent__pk', 'pk').distinct('parent'), - ['<Tag: t2>', '<Tag: t4>', '<Tag: t1>'] + [self.t2, self.t4, self.t1] if connection.features.nulls_order_largest - else ['<Tag: t1>', '<Tag: t2>', '<Tag: t4>'], + else [self.t1, self.t2, self.t4], ), ( StaffTag.objects.select_related('staff').distinct('staff__name').order_by('staff__name'), - ['<StaffTag: t1 -> p1>'], + [self.st1], ), # Fetch the alphabetically first coworker for each worker ( (Staff.objects.distinct('id').order_by('id', 'coworkers__name'). values_list('id', 'coworkers__name')), - ["(1, 'p2')", "(2, 'p1')", "(3, 'p1')", "(4, None)"] + [(1, 'p2'), (2, 'p1'), (3, 'p1'), (4, None)], ), ) for qset, expected in qsets: - self.assertQuerysetEqual(qset, expected) + self.assertSequenceEqual(qset, expected) self.assertEqual(qset.count(), len(expected)) # Combining queries with different distinct_fields is not allowed. diff --git a/tests/expressions/tests.py b/tests/expressions/tests.py index 2762dc3a1b..8bcc7e4673 100644 --- a/tests/expressions/tests.py +++ b/tests/expressions/tests.py @@ -70,9 +70,9 @@ class BasicExpressionsTests(TestCase): companies = Company.objects.annotate( foo=RawSQL('%s', ['value']), ).filter(foo='value').order_by('name') - self.assertQuerysetEqual( + self.assertSequenceEqual( companies, - ['<Company: Example Inc.>', '<Company: Foobar Ltd.>', '<Company: Test GmbH>'], + [self.example_inc, self.foobar_ltd, self.gmbh], ) def test_annotate_values_count(self): @@ -342,10 +342,10 @@ class BasicExpressionsTests(TestCase): def test_ticket_11722_iexact_lookup(self): Employee.objects.create(firstname="John", lastname="Doe") - Employee.objects.create(firstname="Test", lastname="test") + test = Employee.objects.create(firstname="Test", lastname="test") queryset = Employee.objects.filter(firstname__iexact=F('lastname')) - self.assertQuerysetEqual(queryset, ["<Employee: Test test>"]) + self.assertSequenceEqual(queryset, [test]) def test_ticket_16731_startswith_lookup(self): Employee.objects.create(firstname="John", lastname="Doe") @@ -810,44 +810,38 @@ class IterableLookupInnerExpressionsTests(TestCase): # MySQL requires that the values calculated for expressions don't pass # outside of the field's range, so it's inconvenient to use the values # in the more general tests. - Company.objects.create(name='5020 Ltd', num_employees=50, num_chairs=20, ceo=ceo) - Company.objects.create(name='5040 Ltd', num_employees=50, num_chairs=40, ceo=ceo) - Company.objects.create(name='5050 Ltd', num_employees=50, num_chairs=50, ceo=ceo) - Company.objects.create(name='5060 Ltd', num_employees=50, num_chairs=60, ceo=ceo) - cls.c5 = Company.objects.create(name='99300 Ltd', num_employees=99, num_chairs=300, ceo=ceo) + cls.c5020 = Company.objects.create(name='5020 Ltd', num_employees=50, num_chairs=20, ceo=ceo) + cls.c5040 = Company.objects.create(name='5040 Ltd', num_employees=50, num_chairs=40, ceo=ceo) + cls.c5050 = Company.objects.create(name='5050 Ltd', num_employees=50, num_chairs=50, ceo=ceo) + cls.c5060 = Company.objects.create(name='5060 Ltd', num_employees=50, num_chairs=60, ceo=ceo) + cls.c99300 = Company.objects.create(name='99300 Ltd', num_employees=99, num_chairs=300, ceo=ceo) def test_in_lookup_allows_F_expressions_and_expressions_for_integers(self): # __in lookups can use F() expressions for integers. queryset = Company.objects.filter(num_employees__in=([F('num_chairs') - 10])) - self.assertQuerysetEqual(queryset, ['<Company: 5060 Ltd>'], ordered=False) - self.assertQuerysetEqual( + self.assertSequenceEqual(queryset, [self.c5060]) + self.assertCountEqual( Company.objects.filter(num_employees__in=([F('num_chairs') - 10, F('num_chairs') + 10])), - ['<Company: 5040 Ltd>', '<Company: 5060 Ltd>'], - ordered=False + [self.c5040, self.c5060], ) - self.assertQuerysetEqual( + self.assertCountEqual( Company.objects.filter( num_employees__in=([F('num_chairs') - 10, F('num_chairs'), F('num_chairs') + 10]) ), - ['<Company: 5040 Ltd>', '<Company: 5050 Ltd>', '<Company: 5060 Ltd>'], - ordered=False + [self.c5040, self.c5050, self.c5060], ) def test_expressions_in_lookups_join_choice(self): midpoint = datetime.time(13, 0) t1 = Time.objects.create(time=datetime.time(12, 0)) t2 = Time.objects.create(time=datetime.time(14, 0)) - SimulationRun.objects.create(start=t1, end=t2, midpoint=midpoint) + s1 = SimulationRun.objects.create(start=t1, end=t2, midpoint=midpoint) SimulationRun.objects.create(start=t1, end=None, midpoint=midpoint) SimulationRun.objects.create(start=None, end=t2, midpoint=midpoint) SimulationRun.objects.create(start=None, end=None, midpoint=midpoint) queryset = SimulationRun.objects.filter(midpoint__range=[F('start__time'), F('end__time')]) - self.assertQuerysetEqual( - queryset, - ['<SimulationRun: 13:00:00 (12:00:00 to 14:00:00)>'], - ordered=False - ) + self.assertSequenceEqual(queryset, [s1]) for alias in queryset.query.alias_map.values(): if isinstance(alias, Join): self.assertEqual(alias.join_type, constants.INNER) @@ -861,28 +855,21 @@ class IterableLookupInnerExpressionsTests(TestCase): def test_range_lookup_allows_F_expressions_and_expressions_for_integers(self): # Range lookups can use F() expressions for integers. Company.objects.filter(num_employees__exact=F("num_chairs")) - self.assertQuerysetEqual( + self.assertCountEqual( Company.objects.filter(num_employees__range=(F('num_chairs'), 100)), - ['<Company: 5020 Ltd>', '<Company: 5040 Ltd>', '<Company: 5050 Ltd>'], - ordered=False + [self.c5020, self.c5040, self.c5050], ) - self.assertQuerysetEqual( + self.assertCountEqual( Company.objects.filter(num_employees__range=(F('num_chairs') - 10, F('num_chairs') + 10)), - ['<Company: 5040 Ltd>', '<Company: 5050 Ltd>', '<Company: 5060 Ltd>'], - ordered=False + [self.c5040, self.c5050, self.c5060], ) - self.assertQuerysetEqual( + self.assertCountEqual( Company.objects.filter(num_employees__range=(F('num_chairs') - 10, 100)), - ['<Company: 5020 Ltd>', '<Company: 5040 Ltd>', '<Company: 5050 Ltd>', '<Company: 5060 Ltd>'], - ordered=False + [self.c5020, self.c5040, self.c5050, self.c5060], ) - self.assertQuerysetEqual( + self.assertCountEqual( Company.objects.filter(num_employees__range=(1, 100)), - [ - '<Company: 5020 Ltd>', '<Company: 5040 Ltd>', '<Company: 5050 Ltd>', - '<Company: 5060 Ltd>', '<Company: 99300 Ltd>', - ], - ordered=False + [self.c5020, self.c5040, self.c5050, self.c5060, self.c99300], ) def test_range_lookup_namedtuple(self): @@ -890,7 +877,7 @@ class IterableLookupInnerExpressionsTests(TestCase): qs = Company.objects.filter( num_employees__range=EmployeeRange(minimum=51, maximum=100), ) - self.assertSequenceEqual(qs, [self.c5]) + self.assertSequenceEqual(qs, [self.c99300]) @unittest.skipUnless(connection.vendor == 'sqlite', "This defensive test only works on databases that don't validate parameter types") @@ -926,7 +913,7 @@ class IterableLookupInnerExpressionsTests(TestCase): completed=end.date(), estimated_time=end - start, ) - Result.objects.create( + r1 = Result.objects.create( experiment=experiment_1, result_time=datetime.datetime(2016, 2, 4, 15, 0, 0), ) @@ -941,11 +928,11 @@ class IterableLookupInnerExpressionsTests(TestCase): within_experiment_time = [F('experiment__start'), F('experiment__end')] queryset = Result.objects.filter(result_time__range=within_experiment_time) - self.assertQuerysetEqual(queryset, ["<Result: Result at 2016-02-04 15:00:00>"]) + self.assertSequenceEqual(queryset, [r1]) within_experiment_time = [F('experiment__start'), F('experiment__end')] queryset = Result.objects.filter(result_time__range=within_experiment_time) - self.assertQuerysetEqual(queryset, ["<Result: Result at 2016-02-04 15:00:00>"]) + self.assertSequenceEqual(queryset, [r1]) class FTests(SimpleTestCase): @@ -1005,30 +992,27 @@ class ExpressionsTests(TestCase): refs #16731 """ Employee.objects.bulk_create([ - Employee(firstname="%Joh\\nny", lastname="%Joh\\n"), Employee(firstname="Johnny", lastname="%John"), Employee(firstname="Jean-Claude", lastname="Claud_"), - Employee(firstname="Jean-Claude", lastname="Claude"), Employee(firstname="Jean-Claude", lastname="Claude%"), Employee(firstname="Johnny", lastname="Joh\\n"), - Employee(firstname="Johnny", lastname="John"), Employee(firstname="Johnny", lastname="_ohn"), ]) + claude = Employee.objects.create(firstname='Jean-Claude', lastname='Claude') + john = Employee.objects.create(firstname='Johnny', lastname='John') + john_sign = Employee.objects.create(firstname='%Joh\\nny', lastname='%Joh\\n') - self.assertQuerysetEqual( + self.assertCountEqual( Employee.objects.filter(firstname__contains=F('lastname')), - ["<Employee: %Joh\\nny %Joh\\n>", "<Employee: Jean-Claude Claude>", "<Employee: Johnny John>"], - ordered=False, + [john_sign, john, claude], ) - self.assertQuerysetEqual( + self.assertCountEqual( Employee.objects.filter(firstname__startswith=F('lastname')), - ["<Employee: %Joh\\nny %Joh\\n>", "<Employee: Johnny John>"], - ordered=False, + [john_sign, john], ) - self.assertQuerysetEqual( + self.assertSequenceEqual( Employee.objects.filter(firstname__endswith=F('lastname')), - ["<Employee: Jean-Claude Claude>"], - ordered=False, + [claude], ) def test_insensitive_patterns_escape(self): @@ -1038,30 +1022,27 @@ class ExpressionsTests(TestCase): expression -- refs #16731 """ Employee.objects.bulk_create([ - Employee(firstname="%Joh\\nny", lastname="%joh\\n"), Employee(firstname="Johnny", lastname="%john"), Employee(firstname="Jean-Claude", lastname="claud_"), - Employee(firstname="Jean-Claude", lastname="claude"), Employee(firstname="Jean-Claude", lastname="claude%"), Employee(firstname="Johnny", lastname="joh\\n"), - Employee(firstname="Johnny", lastname="john"), Employee(firstname="Johnny", lastname="_ohn"), ]) + claude = Employee.objects.create(firstname='Jean-Claude', lastname='claude') + john = Employee.objects.create(firstname='Johnny', lastname='john') + john_sign = Employee.objects.create(firstname='%Joh\\nny', lastname='%joh\\n') - self.assertQuerysetEqual( + self.assertCountEqual( Employee.objects.filter(firstname__icontains=F('lastname')), - ["<Employee: %Joh\\nny %joh\\n>", "<Employee: Jean-Claude claude>", "<Employee: Johnny john>"], - ordered=False, + [john_sign, john, claude], ) - self.assertQuerysetEqual( + self.assertCountEqual( Employee.objects.filter(firstname__istartswith=F('lastname')), - ["<Employee: %Joh\\nny %joh\\n>", "<Employee: Johnny john>"], - ordered=False, + [john_sign, john], ) - self.assertQuerysetEqual( + self.assertSequenceEqual( Employee.objects.filter(firstname__iendswith=F('lastname')), - ["<Employee: Jean-Claude claude>"], - ordered=False, + [claude], ) @@ -1126,7 +1107,8 @@ class ExpressionsNumericTests(TestCase): """ self.assertQuerysetEqual( Number.objects.all(), - ['<Number: -1, -1.000>', '<Number: 42, 42.000>', '<Number: 1337, 1337.000>'], + [(-1, -1), (42, 42), (1337, 1337)], + lambda n: (n.integer, round(n.float)), ordered=False ) @@ -1137,7 +1119,8 @@ class ExpressionsNumericTests(TestCase): self.assertEqual(Number.objects.filter(integer__gt=0).update(integer=F('integer') + 1), 2) self.assertQuerysetEqual( Number.objects.all(), - ['<Number: -1, -1.000>', '<Number: 43, 42.000>', '<Number: 1338, 1337.000>'], + [(-1, -1), (43, 42), (1338, 1337)], + lambda n: (n.integer, round(n.float)), ordered=False ) @@ -1149,7 +1132,8 @@ class ExpressionsNumericTests(TestCase): self.assertEqual(Number.objects.filter(integer__gt=0).update(integer=F('integer') + 1), 2) self.assertQuerysetEqual( Number.objects.exclude(float=F('integer')), - ['<Number: 43, 42.000>', '<Number: 1338, 1337.000>'], + [(43, 42), (1338, 1337)], + lambda n: (n.integer, round(n.float)), ordered=False ) @@ -1790,15 +1774,15 @@ class FieldTransformTests(TestCase): ) def test_transform_in_values(self): - self.assertQuerysetEqual( + self.assertSequenceEqual( Experiment.objects.values('assigned__month'), - ["{'assigned__month': 6}"] + [{'assigned__month': 6}], ) def test_multiple_transforms_in_values(self): - self.assertQuerysetEqual( + self.assertSequenceEqual( Experiment.objects.values('end__date__month'), - ["{'end__date__month': 6}"] + [{'end__date__month': 6}], ) diff --git a/tests/extra_regress/tests.py b/tests/extra_regress/tests.py index 01bedcbbeb..d459ae6344 100644 --- a/tests/extra_regress/tests.py +++ b/tests/extra_regress/tests.py @@ -118,8 +118,8 @@ class ExtraRegressTests(TestCase): extra() bits. """ qs = User.objects.all().extra(where=['id=%s'], params=[self.u.id]) - self.assertQuerysetEqual(qs, ['<User: fred>']) - self.assertQuerysetEqual(qs[:1], ['<User: fred>']) + self.assertSequenceEqual(qs, [self.u]) + self.assertSequenceEqual(qs[:1], [self.u]) def test_regression_8039(self): """ @@ -140,17 +140,17 @@ class ExtraRegressTests(TestCase): Regression test for #8819: Fields in the extra(select=...) list should be available to extra(order_by=...). """ - self.assertQuerysetEqual( + self.assertSequenceEqual( User.objects.filter(pk=self.u.id).extra(select={'extra_field': 1}).distinct(), - ['<User: fred>'] + [self.u], ) - self.assertQuerysetEqual( + self.assertSequenceEqual( User.objects.filter(pk=self.u.id).extra(select={'extra_field': 1}, order_by=['extra_field']), - ['<User: fred>'] + [self.u], ) - self.assertQuerysetEqual( + self.assertSequenceEqual( User.objects.filter(pk=self.u.id).extra(select={'extra_field': 1}, order_by=['extra_field']).distinct(), - ['<User: fred>'] + [self.u], ) def test_dates_query(self): @@ -364,11 +364,11 @@ class ExtraRegressTests(TestCase): [{'pk': obj.pk}] ) - self.assertQuerysetEqual( + self.assertSequenceEqual( TestObject.objects.filter( pk__in=TestObject.objects.extra(select={'extra': 1}).values('pk') ), - ['<TestObject: TestObject: first,second,third>'] + [obj], ) self.assertEqual( @@ -376,16 +376,16 @@ class ExtraRegressTests(TestCase): [{'pk': obj.pk}] ) - self.assertQuerysetEqual( + self.assertSequenceEqual( TestObject.objects.filter( pk__in=TestObject.objects.values('pk').extra(select={'extra': 1}) ), - ['<TestObject: TestObject: first,second,third>'] + [obj], ) - self.assertQuerysetEqual( + self.assertSequenceEqual( TestObject.objects.filter(pk=obj.pk) | TestObject.objects.extra(where=["id > %s"], params=[obj.pk]), - ['<TestObject: TestObject: first,second,third>'] + [obj], ) def test_regression_17877(self): @@ -394,11 +394,9 @@ class ExtraRegressTests(TestCase): contain OR operations. """ # Test Case 1: should appear in queryset. - t = TestObject(first='a', second='a', third='a') - t.save() + t1 = TestObject.objects.create(first='a', second='a', third='a') # Test Case 2: should appear in queryset. - t = TestObject(first='b', second='a', third='a') - t.save() + t2 = TestObject.objects.create(first='b', second='a', third='a') # Test Case 3: should not appear in queryset, bug case. t = TestObject(first='a', second='a', third='b') t.save() @@ -412,12 +410,11 @@ class ExtraRegressTests(TestCase): t = TestObject(first='a', second='b', third='b') t.save() - self.assertQuerysetEqual( + self.assertCountEqual( TestObject.objects.extra( where=["first = 'a' OR second = 'a'", "third = 'a'"], ), - ['<TestObject: TestObject: a,a,a>', '<TestObject: TestObject: b,a,a>'], - ordered=False + [t1, t2], ) def test_extra_values_distinct_ordering(self): diff --git a/tests/fixtures/tests.py b/tests/fixtures/tests.py index ac96c48734..e072844508 100644 --- a/tests/fixtures/tests.py +++ b/tests/fixtures/tests.py @@ -39,11 +39,13 @@ class TestCaseFixtureLoadingTests(TestCase): def test_class_fixtures(self): "Test case has installed 3 fixture objects" - self.assertQuerysetEqual(Article.objects.all(), [ - '<Article: Django conquers world!>', - '<Article: Copyright is fine the way it is>', - '<Article: Poker has no place on ESPN>', - ]) + self.assertSequenceEqual( + Article.objects.values_list('headline', flat=True), [ + 'Django conquers world!', + 'Copyright is fine the way it is', + 'Poker has no place on ESPN', + ], + ) class SubclassTestCaseFixtureLoadingTests(TestCaseFixtureLoadingTests): @@ -98,10 +100,10 @@ class FixtureLoadingTests(DumpDataAssertMixin, TestCase): Site.objects.all().delete() # Load fixture 1. Single JSON file, with two objects. management.call_command('loaddata', 'fixture1.json', verbosity=0) - self.assertQuerysetEqual(Article.objects.all(), [ - '<Article: Time to reform copyright>', - '<Article: Poker has no place on ESPN>', - ]) + self.assertSequenceEqual( + Article.objects.values_list('headline', flat=True), + ['Time to reform copyright', 'Poker has no place on ESPN'], + ) # Dump the current contents of the database as a JSON fixture self._dumpdata_assert( @@ -184,27 +186,33 @@ class FixtureLoadingTests(DumpDataAssertMixin, TestCase): # Load fixture 2. JSON file imported by default. Overwrites some existing objects management.call_command('loaddata', 'fixture2.json', verbosity=0) - self.assertQuerysetEqual(Article.objects.all(), [ - '<Article: Django conquers world!>', - '<Article: Copyright is fine the way it is>', - '<Article: Poker has no place on ESPN>', - ]) + self.assertSequenceEqual( + Article.objects.values_list('headline', flat=True), + [ + 'Django conquers world!', + 'Copyright is fine the way it is', + 'Poker has no place on ESPN', + ], + ) # Load fixture 3, XML format. management.call_command('loaddata', 'fixture3.xml', verbosity=0) - self.assertQuerysetEqual(Article.objects.all(), [ - '<Article: XML identified as leading cause of cancer>', - '<Article: Django conquers world!>', - '<Article: Copyright is fine the way it is>', - '<Article: Poker on TV is great!>', - ]) + self.assertSequenceEqual( + Article.objects.values_list('headline', flat=True), + [ + 'XML identified as leading cause of cancer', + 'Django conquers world!', + 'Copyright is fine the way it is', + 'Poker on TV is great!', + ], + ) # Load fixture 6, JSON file with dynamic ContentType fields. Testing ManyToOne. management.call_command('loaddata', 'fixture6.json', verbosity=0) self.assertQuerysetEqual(Tag.objects.all(), [ '<Tag: <Article: Copyright is fine the way it is> tagged "copyright">', '<Tag: <Article: Copyright is fine the way it is> tagged "law">', - ], ordered=False) + ], transform=repr, ordered=False) # Load fixture 7, XML file with dynamic ContentType fields. Testing ManyToOne. management.call_command('loaddata', 'fixture7.xml', verbosity=0) @@ -213,7 +221,7 @@ class FixtureLoadingTests(DumpDataAssertMixin, TestCase): '<Tag: <Article: Copyright is fine the way it is> tagged "legal">', '<Tag: <Article: Django conquers world!> tagged "django">', '<Tag: <Article: Django conquers world!> tagged "world domination">', - ], ordered=False) + ], transform=repr, ordered=False) # Load fixture 8, JSON file with dynamic Permission fields. Testing ManyToMany. management.call_command('loaddata', 'fixture8.json', verbosity=0) @@ -221,7 +229,7 @@ class FixtureLoadingTests(DumpDataAssertMixin, TestCase): '<Visa: Django Reinhardt Can add user, Can change user, Can delete user>', '<Visa: Stephane Grappelli Can add user>', '<Visa: Prince >' - ], ordered=False) + ], transform=repr, ordered=False) # Load fixture 9, XML file with dynamic Permission fields. Testing ManyToMany. management.call_command('loaddata', 'fixture9.xml', verbosity=0) @@ -229,15 +237,18 @@ class FixtureLoadingTests(DumpDataAssertMixin, TestCase): '<Visa: Django Reinhardt Can add user, Can change user, Can delete user>', '<Visa: Stephane Grappelli Can add user, Can delete user>', '<Visa: Artist formerly known as "Prince" Can change user>' - ], ordered=False) + ], transform=repr, ordered=False) # object list is unaffected - self.assertQuerysetEqual(Article.objects.all(), [ - '<Article: XML identified as leading cause of cancer>', - '<Article: Django conquers world!>', - '<Article: Copyright is fine the way it is>', - '<Article: Poker on TV is great!>', - ]) + self.assertSequenceEqual( + Article.objects.values_list('headline', flat=True), + [ + 'XML identified as leading cause of cancer', + 'Django conquers world!', + 'Copyright is fine the way it is', + 'Poker on TV is great!', + ], + ) # By default, you get raw keys on dumpdata self._dumpdata_assert( @@ -390,13 +401,15 @@ class FixtureLoadingTests(DumpDataAssertMixin, TestCase): @unittest.skipIf(sys.platform == 'win32', "Windows doesn't support '?' in filenames.") def test_load_fixture_with_special_characters(self): management.call_command('loaddata', 'fixture_with[special]chars', verbosity=0) - self.assertQuerysetEqual(Article.objects.all(), ['<Article: How To Deal With Special Characters>']) + self.assertEqual( + Article.objects.get().headline, + 'How To Deal With Special Characters', + ) def test_dumpdata_with_filtering_manager(self): spy1 = Spy.objects.create(name='Paul') spy2 = Spy.objects.create(name='Alex', cover_blown=True) - self.assertQuerysetEqual(Spy.objects.all(), - ['<Spy: Paul>']) + self.assertSequenceEqual(Spy.objects.all(), [spy1]) # Use the default manager self._dumpdata_assert( ['fixtures.Spy'], @@ -533,50 +546,54 @@ class FixtureLoadingTests(DumpDataAssertMixin, TestCase): def test_compress_format_loading(self): # Load fixture 4 (compressed), using format specification management.call_command('loaddata', 'fixture4.json', verbosity=0) - self.assertQuerysetEqual(Article.objects.all(), [ - '<Article: Django pets kitten>', - ]) + self.assertEqual(Article.objects.get().headline, 'Django pets kitten') def test_compressed_specified_loading(self): # Load fixture 5 (compressed), using format *and* compression specification management.call_command('loaddata', 'fixture5.json.zip', verbosity=0) - self.assertQuerysetEqual(Article.objects.all(), [ - '<Article: WoW subscribers now outnumber readers>', - ]) + self.assertEqual( + Article.objects.get().headline, + 'WoW subscribers now outnumber readers', + ) def test_compressed_loading(self): # Load fixture 5 (compressed), only compression specification management.call_command('loaddata', 'fixture5.zip', verbosity=0) - self.assertQuerysetEqual(Article.objects.all(), [ - '<Article: WoW subscribers now outnumber readers>', - ]) + self.assertEqual( + Article.objects.get().headline, + 'WoW subscribers now outnumber readers', + ) def test_compressed_loading_gzip(self): management.call_command('loaddata', 'fixture5.json.gz', verbosity=0) - self.assertQuerysetEqual(Article.objects.all(), [ - '<Article: WoW subscribers now outnumber readers>', - ]) + self.assertEqual( + Article.objects.get().headline, + 'WoW subscribers now outnumber readers', + ) @unittest.skipUnless(HAS_BZ2, 'No bz2 library detected.') def test_compressed_loading_bz2(self): management.call_command('loaddata', 'fixture5.json.bz2', verbosity=0) - self.assertQuerysetEqual(Article.objects.all(), [ - '<Article: WoW subscribers now outnumber readers>', - ]) + self.assertEqual( + Article.objects.get().headline, + 'WoW subscribers now outnumber readers', + ) @unittest.skipUnless(HAS_LZMA, 'No lzma library detected.') def test_compressed_loading_lzma(self): management.call_command('loaddata', 'fixture5.json.lzma', verbosity=0) - self.assertQuerysetEqual(Article.objects.all(), [ - '<Article: WoW subscribers now outnumber readers>', - ]) + self.assertEqual( + Article.objects.get().headline, + 'WoW subscribers now outnumber readers', + ) @unittest.skipUnless(HAS_LZMA, 'No lzma library detected.') def test_compressed_loading_xz(self): management.call_command('loaddata', 'fixture5.json.xz', verbosity=0) - self.assertQuerysetEqual(Article.objects.all(), [ - '<Article: WoW subscribers now outnumber readers>', - ]) + self.assertEqual( + Article.objects.get().headline, + 'WoW subscribers now outnumber readers', + ) def test_ambiguous_compressed_fixture(self): # The name "fixture5" is ambiguous, so loading raises an error. @@ -588,10 +605,13 @@ class FixtureLoadingTests(DumpDataAssertMixin, TestCase): # Load db fixtures 1 and 2. These will load using the 'default' database identifier implicitly management.call_command('loaddata', 'db_fixture_1', verbosity=0) management.call_command('loaddata', 'db_fixture_2', verbosity=0) - self.assertQuerysetEqual(Article.objects.all(), [ - '<Article: Who needs more than one database?>', - '<Article: Who needs to use compressed data?>', - ]) + self.assertSequenceEqual( + Article.objects.values_list('headline', flat=True), + [ + 'Who needs more than one database?', + 'Who needs to use compressed data?', + ], + ) def test_loaddata_error_message(self): """ @@ -622,9 +642,10 @@ class FixtureLoadingTests(DumpDataAssertMixin, TestCase): management.call_command('loaddata', 'db_fixture_1', verbosity=0, app_label="someotherapp") self.assertQuerysetEqual(Article.objects.all(), []) management.call_command('loaddata', 'db_fixture_1', verbosity=0, app_label="fixtures") - self.assertQuerysetEqual(Article.objects.all(), [ - '<Article: Who needs more than one database?>', - ]) + self.assertEqual( + Article.objects.get().headline, + 'Who needs more than one database?', + ) def test_loaddata_verbosity_three(self): output = StringIO() @@ -640,10 +661,13 @@ class FixtureLoadingTests(DumpDataAssertMixin, TestCase): # Load db fixtures 1 and 2. These will load using the 'default' database identifier explicitly management.call_command('loaddata', 'db_fixture_1', verbosity=0, database='default') management.call_command('loaddata', 'db_fixture_2', verbosity=0, database='default') - self.assertQuerysetEqual(Article.objects.all(), [ - '<Article: Who needs more than one database?>', - '<Article: Who needs to use compressed data?>', - ]) + self.assertSequenceEqual( + Article.objects.values_list('headline', flat=True), + [ + 'Who needs more than one database?', + 'Who needs to use compressed data?', + ], + ) def test_unmatched_identifier_loading(self): # Try to load db fixture 3. This won't load because the database identifier doesn't match @@ -662,7 +686,7 @@ class FixtureLoadingTests(DumpDataAssertMixin, TestCase): self.assertQuerysetEqual(Tag.objects.all(), [ '<Tag: <Article: Time to reform copyright> tagged "copyright">', '<Tag: <Article: Time to reform copyright> tagged "law">' - ], ordered=False) + ], transform=repr, ordered=False) # Dump the current contents of the database as a JSON fixture self._dumpdata_assert( @@ -707,14 +731,14 @@ class FixtureLoadingTests(DumpDataAssertMixin, TestCase): management.call_command('loaddata', 'fixture1', exclude=['fixtures'], verbosity=0) self.assertFalse(Article.objects.exists()) self.assertFalse(Category.objects.exists()) - self.assertQuerysetEqual(Site.objects.all(), ['<Site: example.com>']) + self.assertEqual(Site.objects.get().domain, 'example.com') def test_loading_with_exclude_model(self): Site.objects.all().delete() management.call_command('loaddata', 'fixture1', exclude=['fixtures.Article'], verbosity=0) self.assertFalse(Article.objects.exists()) - self.assertQuerysetEqual(Category.objects.all(), ['<Category: News Stories>']) - self.assertQuerysetEqual(Site.objects.all(), ['<Site: example.com>']) + self.assertEqual(Category.objects.get().title, 'News Stories') + self.assertEqual(Site.objects.get().domain, 'example.com') def test_exclude_option_errors(self): """Excluding a bogus app or model should raise an error.""" @@ -740,18 +764,21 @@ class FixtureLoadingTests(DumpDataAssertMixin, TestCase): with mock.patch('django.core.management.commands.loaddata.sys.stdin', open(fixture_json)): management.call_command('loaddata', '--format=json', '-', verbosity=0) - self.assertQuerysetEqual(Article.objects.all(), [ - '<Article: Time to reform copyright>', - '<Article: Poker has no place on ESPN>', - ]) + self.assertSequenceEqual( + Article.objects.values_list('headline', flat=True), + ['Time to reform copyright', 'Poker has no place on ESPN'], + ) with mock.patch('django.core.management.commands.loaddata.sys.stdin', open(fixture_xml)): management.call_command('loaddata', '--format=xml', '-', verbosity=0) - self.assertQuerysetEqual(Article.objects.all(), [ - '<Article: XML identified as leading cause of cancer>', - '<Article: Time to reform copyright>', - '<Article: Poker on TV is great!>', - ]) + self.assertSequenceEqual( + Article.objects.values_list('headline', flat=True), + [ + 'XML identified as leading cause of cancer', + 'Time to reform copyright', + 'Poker on TV is great!', + ], + ) class NonexistentFixtureTests(TestCase): @@ -789,10 +816,10 @@ class FixtureTransactionTests(DumpDataAssertMixin, TransactionTestCase): def test_format_discovery(self): # Load fixture 1 again, using format discovery management.call_command('loaddata', 'fixture1', verbosity=0) - self.assertQuerysetEqual(Article.objects.all(), [ - '<Article: Time to reform copyright>', - '<Article: Poker has no place on ESPN>', - ]) + self.assertSequenceEqual( + Article.objects.values_list('headline', flat=True), + ['Time to reform copyright', 'Poker has no place on ESPN'], + ) # Try to load fixture 2 using format discovery; this will fail # because there are two fixture2's in the fixtures directory @@ -801,10 +828,10 @@ class FixtureTransactionTests(DumpDataAssertMixin, TransactionTestCase): management.call_command('loaddata', 'fixture2', verbosity=0) # object list is unaffected - self.assertQuerysetEqual(Article.objects.all(), [ - '<Article: Time to reform copyright>', - '<Article: Poker has no place on ESPN>', - ]) + self.assertSequenceEqual( + Article.objects.values_list('headline', flat=True), + ['Time to reform copyright', 'Poker has no place on ESPN'], + ) # Dump the current contents of the database as a JSON fixture self._dumpdata_assert( @@ -817,11 +844,14 @@ class FixtureTransactionTests(DumpDataAssertMixin, TransactionTestCase): # Load fixture 4 (compressed), using format discovery management.call_command('loaddata', 'fixture4', verbosity=0) - self.assertQuerysetEqual(Article.objects.all(), [ - '<Article: Django pets kitten>', - '<Article: Time to reform copyright>', - '<Article: Poker has no place on ESPN>', - ]) + self.assertSequenceEqual( + Article.objects.values_list('headline', flat=True), + [ + 'Django pets kitten', + 'Time to reform copyright', + 'Poker has no place on ESPN', + ], + ) class ForwardReferenceTests(DumpDataAssertMixin, TestCase): @@ -861,9 +891,9 @@ class ForwardReferenceTests(DumpDataAssertMixin, TestCase): management.call_command('loaddata', 'forward_reference_m2m.json', verbosity=0) self.assertEqual(NaturalKeyThing.objects.count(), 3) t1 = NaturalKeyThing.objects.get_by_natural_key('t1') - self.assertQuerysetEqual( - t1.other_things.order_by('key'), - ['<NaturalKeyThing: t2>', '<NaturalKeyThing: t3>'] + self.assertSequenceEqual( + t1.other_things.order_by('key').values_list('key', flat=True), + ['t2', 't3'], ) self._dumpdata_assert( ['fixtures'], @@ -883,9 +913,9 @@ class ForwardReferenceTests(DumpDataAssertMixin, TestCase): ) self.assertEqual(NaturalKeyThing.objects.count(), 3) t1 = NaturalKeyThing.objects.get_by_natural_key('t1') - self.assertQuerysetEqual( - t1.other_things.order_by('key'), - ['<NaturalKeyThing: t2>', '<NaturalKeyThing: t3>'] + self.assertSequenceEqual( + t1.other_things.order_by('key').values_list('key', flat=True), + ['t2', 't3'], ) self._dumpdata_assert( ['fixtures'], diff --git a/tests/fixtures_regress/tests.py b/tests/fixtures_regress/tests.py index cc4cee3de4..4a22dc0246 100644 --- a/tests/fixtures_regress/tests.py +++ b/tests/fixtures_regress/tests.py @@ -747,7 +747,8 @@ class NaturalKeyFixtureTests(TestCase): "<Book: Cryptonomicon by Neal Stephenson (available at Amazon, Borders)>", "<Book: Ender's Game by Orson Scott Card (available at Collins Bookstore)>", "<Book: Permutation City by Greg Egan (available at Angus and Robertson)>", - ] + ], + transform=repr, ) @@ -845,10 +846,7 @@ class M2MNaturalKeyFixtureTests(TestCase): obj.save() new_a = M2MSimpleA.objects.get_by_natural_key("a") - self.assertQuerysetEqual(new_a.b_set.all(), [ - "<M2MSimpleB: b1>", - "<M2MSimpleB: b2>" - ], ordered=False) + self.assertCountEqual(new_a.b_set.all(), [b1, b2]) class TestTicket11101(TransactionTestCase): diff --git a/tests/foreign_object/tests.py b/tests/foreign_object/tests.py index a33f29a38c..2473a0a732 100644 --- a/tests/foreign_object/tests.py +++ b/tests/foreign_object/tests.py @@ -408,15 +408,15 @@ class MultiColumnFKTests(TestCase): Person.objects.bulk_create(objs, 10) def test_isnull_lookup(self): - Membership.objects.create(membership_country=self.usa, person=self.bob, group_id=None) - Membership.objects.create(membership_country=self.usa, person=self.bob, group=self.cia) - self.assertQuerysetEqual( + m1 = Membership.objects.create(membership_country=self.usa, person=self.bob, group_id=None) + m2 = Membership.objects.create(membership_country=self.usa, person=self.bob, group=self.cia) + self.assertSequenceEqual( Membership.objects.filter(group__isnull=True), - ['<Membership: Bob is a member of NULL>'] + [m1], ) - self.assertQuerysetEqual( + self.assertSequenceEqual( Membership.objects.filter(group__isnull=False), - ['<Membership: Bob is a member of CIA>'] + [m2], ) diff --git a/tests/generic_relations/tests.py b/tests/generic_relations/tests.py index 0eb9dee03b..2402f3d031 100644 --- a/tests/generic_relations/tests.py +++ b/tests/generic_relations/tests.py @@ -25,10 +25,10 @@ class GenericRelationsTests(TestCase): cls.quartz = Mineral.objects.create(name='Quartz', hardness=7) # Tagging stuff. - cls.bacon.tags.create(tag='fatty') - cls.bacon.tags.create(tag='salty') - cls.lion.tags.create(tag='yellow') - cls.lion.tags.create(tag='hairy') + cls.fatty = cls.bacon.tags.create(tag='fatty') + cls.salty = cls.bacon.tags.create(tag='salty') + cls.yellow = cls.lion.tags.create(tag='yellow') + cls.hairy = cls.lion.tags.create(tag='hairy') def comp_func(self, obj): # Original list of tags: @@ -86,14 +86,8 @@ class GenericRelationsTests(TestCase): Objects with declared GenericRelations can be tagged directly -- the API mimics the many-to-many API. """ - self.assertQuerysetEqual(self.lion.tags.all(), [ - "<TaggedItem: hairy>", - "<TaggedItem: yellow>" - ]) - self.assertQuerysetEqual(self.bacon.tags.all(), [ - "<TaggedItem: fatty>", - "<TaggedItem: salty>" - ]) + self.assertSequenceEqual(self.lion.tags.all(), [self.hairy, self.yellow]) + self.assertSequenceEqual(self.bacon.tags.all(), [self.fatty, self.salty]) def test_access_content_object(self): """ @@ -105,9 +99,7 @@ class GenericRelationsTests(TestCase): def test_query_content_object(self): qs = TaggedItem.objects.filter( animal__isnull=False).order_by('animal__common_name', 'tag') - self.assertQuerysetEqual( - qs, ["<TaggedItem: hairy>", "<TaggedItem: yellow>"] - ) + self.assertSequenceEqual(qs, [self.hairy, self.yellow]) mpk = ManualPK.objects.create(id=1) mpk.tags.create(tag='mpk') @@ -124,17 +116,14 @@ class GenericRelationsTests(TestCase): # defined. That's OK, because you can create TaggedItems explicitly. # However, excluding GenericRelations means your lookups have to be a # bit more explicit. - TaggedItem.objects.create(content_object=self.quartz, tag="shiny") - TaggedItem.objects.create(content_object=self.quartz, tag="clearish") + shiny = TaggedItem.objects.create(content_object=self.quartz, tag="shiny") + clearish = TaggedItem.objects.create(content_object=self.quartz, tag="clearish") ctype = ContentType.objects.get_for_model(self.quartz) q = TaggedItem.objects.filter( content_type__pk=ctype.id, object_id=self.quartz.id ) - self.assertQuerysetEqual(q, [ - "<TaggedItem: clearish>", - "<TaggedItem: shiny>" - ]) + self.assertSequenceEqual(q, [clearish, shiny]) def test_access_via_content_type(self): """ @@ -145,9 +134,10 @@ class GenericRelationsTests(TestCase): ctype = ContentType.objects.get_for_model(self.platypus) - self.assertQuerysetEqual( + self.assertSequenceEqual( Animal.objects.filter(tags__content_type=ctype), - ["<Animal: Platypus>"]) + [self.platypus], + ) def test_set_foreign_key(self): """ @@ -157,9 +147,7 @@ class GenericRelationsTests(TestCase): tag1.content_object = self.platypus tag1.save() - self.assertQuerysetEqual( - self.platypus.tags.all(), - ["<TaggedItem: shiny>"]) + self.assertSequenceEqual(self.platypus.tags.all(), [tag1]) def test_queries_across_generic_relations(self): """ @@ -167,10 +155,10 @@ class GenericRelationsTests(TestCase): there are two TaggedItems with a tag of "fatty", this query only pulls out the one with the content type related to Animals. """ - self.assertQuerysetEqual(Animal.objects.order_by('common_name'), [ - "<Animal: Lion>", - "<Animal: Platypus>" - ]) + self.assertSequenceEqual( + Animal.objects.order_by('common_name'), + [self.lion, self.platypus], + ) def test_queries_content_type_restriction(self): """ @@ -181,10 +169,14 @@ class GenericRelationsTests(TestCase): mpk.tags.create(tag="fatty") self.platypus.tags.create(tag="fatty") - self.assertQuerysetEqual( - Animal.objects.filter(tags__tag='fatty'), ["<Animal: Platypus>"]) - self.assertQuerysetEqual( - Animal.objects.exclude(tags__tag='fatty'), ["<Animal: Lion>"]) + self.assertSequenceEqual( + Animal.objects.filter(tags__tag='fatty'), + [self.platypus], + ) + self.assertSequenceEqual( + Animal.objects.exclude(tags__tag='fatty'), + [self.lion], + ) def test_object_deletion_with_generic_relation(self): """ @@ -236,7 +228,7 @@ class GenericRelationsTests(TestCase): content_type__pk=ctype.id, object_id=self.lion.id, tag="hairy") tag.delete() - self.assertQuerysetEqual(self.lion.tags.all(), ["<TaggedItem: yellow>"]) + self.assertSequenceEqual(self.lion.tags.all(), [self.yellow]) self.assertQuerysetEqual(TaggedItem.objects.all(), [ ('fatty', Vegetable, self.bacon.pk), ('salty', Vegetable, self.bacon.pk), @@ -282,32 +274,22 @@ class GenericRelationsTests(TestCase): salty = bacon.tags.create(tag="salty") bacon.tags.set([fatty, salty]) - self.assertQuerysetEqual(bacon.tags.all(), [ - "<TaggedItem: fatty>", - "<TaggedItem: salty>", - ]) + self.assertSequenceEqual(bacon.tags.all(), [fatty, salty]) bacon.tags.set([fatty]) - self.assertQuerysetEqual(bacon.tags.all(), [ - "<TaggedItem: fatty>", - ]) + self.assertSequenceEqual(bacon.tags.all(), [fatty]) bacon.tags.set([]) - self.assertQuerysetEqual(bacon.tags.all(), []) + self.assertSequenceEqual(bacon.tags.all(), []) bacon.tags.set([fatty, salty], bulk=False, clear=True) - self.assertQuerysetEqual(bacon.tags.all(), [ - "<TaggedItem: fatty>", - "<TaggedItem: salty>", - ]) + self.assertSequenceEqual(bacon.tags.all(), [fatty, salty]) bacon.tags.set([fatty], bulk=False, clear=True) - self.assertQuerysetEqual(bacon.tags.all(), [ - "<TaggedItem: fatty>", - ]) + self.assertSequenceEqual(bacon.tags.all(), [fatty]) bacon.tags.set([], clear=True) - self.assertQuerysetEqual(bacon.tags.all(), []) + self.assertSequenceEqual(bacon.tags.all(), []) def test_assign(self): bacon = Vegetable.objects.create(name="Bacon", is_yucky=False) @@ -315,18 +297,13 @@ class GenericRelationsTests(TestCase): salty = bacon.tags.create(tag="salty") bacon.tags.set([fatty, salty]) - self.assertQuerysetEqual(bacon.tags.all(), [ - "<TaggedItem: fatty>", - "<TaggedItem: salty>", - ]) + self.assertSequenceEqual(bacon.tags.all(), [fatty, salty]) bacon.tags.set([fatty]) - self.assertQuerysetEqual(bacon.tags.all(), [ - "<TaggedItem: fatty>", - ]) + self.assertSequenceEqual(bacon.tags.all(), [fatty]) bacon.tags.set([]) - self.assertQuerysetEqual(bacon.tags.all(), []) + self.assertSequenceEqual(bacon.tags.all(), []) def test_assign_with_queryset(self): # Querysets used in reverse GFK assignments are pre-evaluated so their @@ -361,42 +338,35 @@ class GenericRelationsTests(TestCase): bear = Animal.objects.create(common_name="bear") # Create directly - Comparison.objects.create( + c1 = Comparison.objects.create( first_obj=cheetah, other_obj=tiger, comparative="faster" ) - Comparison.objects.create( + c2 = Comparison.objects.create( first_obj=tiger, other_obj=cheetah, comparative="cooler" ) # Create using GenericRelation - tiger.comparisons.create(other_obj=bear, comparative="cooler") - tiger.comparisons.create(other_obj=cheetah, comparative="stronger") - self.assertQuerysetEqual(cheetah.comparisons.all(), [ - "<Comparison: cheetah is faster than tiger>" - ]) + c3 = tiger.comparisons.create(other_obj=bear, comparative="cooler") + c4 = tiger.comparisons.create(other_obj=cheetah, comparative="stronger") + self.assertSequenceEqual(cheetah.comparisons.all(), [c1]) # Filtering works - self.assertQuerysetEqual(tiger.comparisons.filter(comparative="cooler"), [ - "<Comparison: tiger is cooler than cheetah>", - "<Comparison: tiger is cooler than bear>", - ], ordered=False) + self.assertCountEqual( + tiger.comparisons.filter(comparative='cooler'), + [c2, c3], + ) # Filtering and deleting works subjective = ["cooler"] tiger.comparisons.filter(comparative__in=subjective).delete() - self.assertQuerysetEqual(Comparison.objects.all(), [ - "<Comparison: cheetah is faster than tiger>", - "<Comparison: tiger is stronger than cheetah>" - ], ordered=False) + self.assertCountEqual(Comparison.objects.all(), [c1, c4]) # If we delete cheetah, Comparisons with cheetah as 'first_obj' will be # deleted since Animal has an explicit GenericRelation to Comparison # through first_obj. Comparisons with cheetah as 'other_obj' will not # be deleted. cheetah.delete() - self.assertQuerysetEqual(Comparison.objects.all(), [ - "<Comparison: tiger is stronger than None>" - ]) + self.assertSequenceEqual(Comparison.objects.all(), [c4]) def test_gfk_subclasses(self): # GenericForeignKey should work with subclasses (see #8309) diff --git a/tests/generic_views/test_edit.py b/tests/generic_views/test_edit.py index bdabf1d0d2..ca7c457124 100644 --- a/tests/generic_views/test_edit.py +++ b/tests/generic_views/test_edit.py @@ -105,7 +105,7 @@ class CreateViewTests(TestCase): res = self.client.post('/edit/authors/create/', {'name': 'Randall Munroe', 'slug': 'randall-munroe'}) self.assertEqual(res.status_code, 302) self.assertRedirects(res, '/list/authors/') - self.assertQuerysetEqual(Author.objects.all(), ['<Author: Randall Munroe>']) + self.assertQuerysetEqual(Author.objects.values_list('name', flat=True), ['Randall Munroe']) def test_create_invalid(self): res = self.client.post('/edit/authors/create/', {'name': 'A' * 101, 'slug': 'randall-munroe'}) @@ -119,20 +119,20 @@ class CreateViewTests(TestCase): self.assertEqual(res.status_code, 302) artist = Artist.objects.get(name='Rene Magritte') self.assertRedirects(res, '/detail/artist/%d/' % artist.pk) - self.assertQuerysetEqual(Artist.objects.all(), ['<Artist: Rene Magritte>']) + self.assertQuerysetEqual(Artist.objects.all(), [artist]) def test_create_with_redirect(self): res = self.client.post('/edit/authors/create/redirect/', {'name': 'Randall Munroe', 'slug': 'randall-munroe'}) self.assertEqual(res.status_code, 302) self.assertRedirects(res, '/edit/authors/create/') - self.assertQuerysetEqual(Author.objects.all(), ['<Author: Randall Munroe>']) + self.assertQuerysetEqual(Author.objects.values_list('name', flat=True), ['Randall Munroe']) def test_create_with_interpolated_redirect(self): res = self.client.post( '/edit/authors/create/interpolate_redirect/', {'name': 'Randall Munroe', 'slug': 'randall-munroe'} ) - self.assertQuerysetEqual(Author.objects.all(), ['<Author: Randall Munroe>']) + self.assertQuerysetEqual(Author.objects.values_list('name', flat=True), ['Randall Munroe']) self.assertEqual(res.status_code, 302) pk = Author.objects.first().pk self.assertRedirects(res, '/edit/author/%d/update/' % pk) @@ -157,7 +157,7 @@ class CreateViewTests(TestCase): self.assertEqual(res.status_code, 302) obj = Author.objects.get(slug='randall-munroe') self.assertRedirects(res, reverse('author_detail', kwargs={'pk': obj.pk})) - self.assertQuerysetEqual(Author.objects.all(), ['<Author: Randall Munroe>']) + self.assertQuerysetEqual(Author.objects.all(), [obj]) def test_create_without_redirect(self): msg = ( @@ -239,7 +239,7 @@ class UpdateViewTests(TestCase): ) self.assertEqual(res.status_code, 302) self.assertRedirects(res, '/list/authors/') - self.assertQuerysetEqual(Author.objects.all(), ['<Author: Randall Munroe (xkcd)>']) + self.assertQuerysetEqual(Author.objects.values_list('name', flat=True), ['Randall Munroe (xkcd)']) def test_update_invalid(self): res = self.client.post( @@ -249,7 +249,7 @@ class UpdateViewTests(TestCase): self.assertEqual(res.status_code, 200) self.assertTemplateUsed(res, 'generic_views/author_form.html') self.assertEqual(len(res.context['form'].errors), 1) - self.assertQuerysetEqual(Author.objects.all(), ['<Author: Randall Munroe>']) + self.assertQuerysetEqual(Author.objects.all(), [self.author]) self.assertEqual(res.context['view'].get_form_called_count, 1) def test_update_with_object_url(self): @@ -257,7 +257,7 @@ class UpdateViewTests(TestCase): res = self.client.post('/edit/artists/%d/update/' % a.pk, {'name': 'Rene Magritte'}) self.assertEqual(res.status_code, 302) self.assertRedirects(res, '/detail/artist/%d/' % a.pk) - self.assertQuerysetEqual(Artist.objects.all(), ['<Artist: Rene Magritte>']) + self.assertQuerysetEqual(Artist.objects.all(), [a]) def test_update_with_redirect(self): res = self.client.post( @@ -266,14 +266,14 @@ class UpdateViewTests(TestCase): ) self.assertEqual(res.status_code, 302) self.assertRedirects(res, '/edit/authors/create/') - self.assertQuerysetEqual(Author.objects.all(), ['<Author: Randall Munroe (author of xkcd)>']) + self.assertQuerysetEqual(Author.objects.values_list('name', flat=True), ['Randall Munroe (author of xkcd)']) def test_update_with_interpolated_redirect(self): res = self.client.post( '/edit/author/%d/update/interpolate_redirect/' % self.author.pk, {'name': 'Randall Munroe (author of xkcd)', 'slug': 'randall-munroe'} ) - self.assertQuerysetEqual(Author.objects.all(), ['<Author: Randall Munroe (author of xkcd)>']) + self.assertQuerysetEqual(Author.objects.values_list('name', flat=True), ['Randall Munroe (author of xkcd)']) self.assertEqual(res.status_code, 302) pk = Author.objects.first().pk self.assertRedirects(res, '/edit/author/%d/update/' % pk) @@ -301,7 +301,7 @@ class UpdateViewTests(TestCase): ) self.assertEqual(res.status_code, 302) self.assertRedirects(res, '/detail/author/%d/' % self.author.pk) - self.assertQuerysetEqual(Author.objects.all(), ['<Author: Randall Munroe (author of xkcd)>']) + self.assertQuerysetEqual(Author.objects.values_list('name', flat=True), ['Randall Munroe (author of xkcd)']) def test_update_without_redirect(self): msg = ( @@ -327,7 +327,7 @@ class UpdateViewTests(TestCase): res = self.client.post('/edit/author/update/', {'name': 'Randall Munroe (xkcd)', 'slug': 'randall-munroe'}) self.assertEqual(res.status_code, 302) self.assertRedirects(res, '/list/authors/') - self.assertQuerysetEqual(Author.objects.all(), ['<Author: Randall Munroe (xkcd)>']) + self.assertQuerysetEqual(Author.objects.values_list('name', flat=True), ['Randall Munroe (xkcd)']) @override_settings(ROOT_URLCONF='generic_views.urls') diff --git a/tests/lookup/test_timefield.py b/tests/lookup/test_timefield.py index 6ef1d794e2..1fa02bc596 100644 --- a/tests/lookup/test_timefield.py +++ b/tests/lookup/test_timefield.py @@ -13,22 +13,19 @@ class TimeFieldLookupTests(TestCase): self.al3 = Alarm.objects.create(desc='Precise', time='12:34:56') def test_hour_lookups(self): - self.assertQuerysetEqual( + self.assertSequenceEqual( Alarm.objects.filter(time__hour=5), - ['<Alarm: 05:30:00 (Early)>'], - ordered=False + [self.al1], ) def test_minute_lookups(self): - self.assertQuerysetEqual( + self.assertSequenceEqual( Alarm.objects.filter(time__minute=30), - ['<Alarm: 05:30:00 (Early)>'], - ordered=False + [self.al1], ) def test_second_lookups(self): - self.assertQuerysetEqual( + self.assertSequenceEqual( Alarm.objects.filter(time__second=56), - ['<Alarm: 12:34:56 (Precise)>'], - ordered=False + [self.al3], ) diff --git a/tests/lookup/tests.py b/tests/lookup/tests.py index 9094542808..9962d34937 100644 --- a/tests/lookup/tests.py +++ b/tests/lookup/tests.py @@ -84,23 +84,17 @@ class LookupTests(TestCase): def test_lookup_int_as_str(self): # Integer value can be queried using string - self.assertQuerysetEqual(Article.objects.filter(id__iexact=str(self.a1.id)), - ['<Article: Article 1>']) + self.assertSequenceEqual( + Article.objects.filter(id__iexact=str(self.a1.id)), + [self.a1], + ) @skipUnlessDBFeature('supports_date_lookup_using_string') def test_lookup_date_as_str(self): # A date lookup can be performed using a string search - self.assertQuerysetEqual( + self.assertSequenceEqual( Article.objects.filter(pub_date__startswith='2005'), - [ - '<Article: Article 5>', - '<Article: Article 6>', - '<Article: Article 4>', - '<Article: Article 2>', - '<Article: Article 3>', - '<Article: Article 7>', - '<Article: Article 1>', - ] + [self.a5, self.a6, self.a4, self.a2, self.a3, self.a7, self.a1], ) def test_iterator(self): @@ -492,96 +486,48 @@ class LookupTests(TestCase): 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. - Article.objects.create(headline='Article_ with underscore', pub_date=datetime(2005, 11, 20)) + a8 = Article.objects.create(headline='Article_ with underscore', pub_date=datetime(2005, 11, 20)) - self.assertQuerysetEqual( + self.assertSequenceEqual( Article.objects.filter(headline__startswith='Article'), - [ - '<Article: Article_ with underscore>', - '<Article: Article 5>', - '<Article: Article 6>', - '<Article: Article 4>', - '<Article: Article 2>', - '<Article: Article 3>', - '<Article: Article 7>', - '<Article: Article 1>', - ] + [a8, self.a5, self.a6, self.a4, self.a2, self.a3, self.a7, self.a1], ) - self.assertQuerysetEqual( + self.assertSequenceEqual( Article.objects.filter(headline__startswith='Article_'), - ['<Article: Article_ with underscore>'] + [a8], ) - Article.objects.create(headline='Article% with percent sign', pub_date=datetime(2005, 11, 21)) - self.assertQuerysetEqual( + a9 = Article.objects.create(headline='Article% with percent sign', pub_date=datetime(2005, 11, 21)) + self.assertSequenceEqual( Article.objects.filter(headline__startswith='Article'), - [ - '<Article: Article% with percent sign>', - '<Article: Article_ with underscore>', - '<Article: Article 5>', - '<Article: Article 6>', - '<Article: Article 4>', - '<Article: Article 2>', - '<Article: Article 3>', - '<Article: Article 7>', - '<Article: Article 1>', - ] + [a9, a8, self.a5, self.a6, self.a4, self.a2, self.a3, self.a7, self.a1], ) - self.assertQuerysetEqual( + self.assertSequenceEqual( Article.objects.filter(headline__startswith='Article%'), - ['<Article: Article% with percent sign>'] + [a9], ) - Article.objects.create(headline='Article with \\ backslash', pub_date=datetime(2005, 11, 22)) - self.assertQuerysetEqual( + a10 = Article.objects.create(headline='Article with \\ backslash', pub_date=datetime(2005, 11, 22)) + self.assertSequenceEqual( Article.objects.filter(headline__contains='\\'), - [r'<Article: Article with \ backslash>'] + [a10], ) def test_exclude(self): - Article.objects.bulk_create([ - Article(headline='Article_ with underscore', pub_date=datetime(2005, 11, 20)), - Article(headline='Article% with percent sign', pub_date=datetime(2005, 11, 21)), - Article(headline='Article with \\ backslash', pub_date=datetime(2005, 11, 22)), - ]) + pub_date = datetime(2005, 11, 20) + a8 = Article.objects.create(headline='Article_ with underscore', pub_date=pub_date) + a9 = Article.objects.create(headline='Article% with percent sign', pub_date=pub_date) + a10 = Article.objects.create(headline='Article with \\ backslash', pub_date=pub_date) # exclude() is the opposite of filter() when doing lookups: - self.assertQuerysetEqual( + self.assertSequenceEqual( Article.objects.filter(headline__contains='Article').exclude(headline__contains='with'), - [ - '<Article: Article 5>', - '<Article: Article 6>', - '<Article: Article 4>', - '<Article: Article 2>', - '<Article: Article 3>', - '<Article: Article 7>', - '<Article: Article 1>', - ] + [self.a5, self.a6, self.a4, self.a2, self.a3, self.a7, self.a1], ) - self.assertQuerysetEqual( + self.assertSequenceEqual( Article.objects.exclude(headline__startswith="Article_"), - [ - '<Article: Article with \\ backslash>', - '<Article: Article% with percent sign>', - '<Article: Article 5>', - '<Article: Article 6>', - '<Article: Article 4>', - '<Article: Article 2>', - '<Article: Article 3>', - '<Article: Article 7>', - '<Article: Article 1>', - ] + [a10, a9, self.a5, self.a6, self.a4, self.a2, self.a3, self.a7, self.a1], ) - self.assertQuerysetEqual( + self.assertSequenceEqual( Article.objects.exclude(headline="Article 7"), - [ - '<Article: Article with \\ backslash>', - '<Article: Article% with percent sign>', - '<Article: Article_ with underscore>', - '<Article: Article 5>', - '<Article: Article 6>', - '<Article: Article 4>', - '<Article: Article 2>', - '<Article: Article 3>', - '<Article: Article 1>', - ] + [a10, a9, a8, self.a5, self.a6, self.a4, self.a2, self.a3, self.a1], ) def test_none(self): @@ -594,17 +540,9 @@ class LookupTests(TestCase): self.assertQuerysetEqual(Article.objects.none().iterator(), []) def test_in(self): - self.assertQuerysetEqual( + self.assertSequenceEqual( Article.objects.exclude(id__in=[]), - [ - '<Article: Article 5>', - '<Article: Article 6>', - '<Article: Article 4>', - '<Article: Article 2>', - '<Article: Article 3>', - '<Article: Article 7>', - '<Article: Article 1>', - ] + [self.a5, self.a6, self.a4, self.a2, self.a3, self.a7, self.a1], ) def test_in_empty_list(self): @@ -706,49 +644,52 @@ class LookupTests(TestCase): # zero-or-more self.assertQuerysetEqual( Article.objects.filter(headline__regex=r'fo*'), - ['<Article: f>', '<Article: fo>', '<Article: foo>', '<Article: fooo>'] + Article.objects.filter(headline__in=['f', 'fo', 'foo', 'fooo']), ) self.assertQuerysetEqual( Article.objects.filter(headline__iregex=r'fo*'), - [ - '<Article: f>', - '<Article: fo>', - '<Article: foo>', - '<Article: fooo>', - '<Article: hey-Foo>', - ] + Article.objects.filter(headline__in=['f', 'fo', 'foo', 'fooo', 'hey-Foo']), ) # one-or-more self.assertQuerysetEqual( Article.objects.filter(headline__regex=r'fo+'), - ['<Article: fo>', '<Article: foo>', '<Article: fooo>'] + Article.objects.filter(headline__in=['fo', 'foo', 'fooo']), ) # wildcard self.assertQuerysetEqual( Article.objects.filter(headline__regex=r'fooo?'), - ['<Article: foo>', '<Article: fooo>'] + Article.objects.filter(headline__in=['foo', 'fooo']), ) # leading anchor self.assertQuerysetEqual( Article.objects.filter(headline__regex=r'^b'), - ['<Article: bar>', '<Article: baxZ>', '<Article: baz>'] + Article.objects.filter(headline__in=['bar', 'baxZ', 'baz']), + ) + self.assertQuerysetEqual( + Article.objects.filter(headline__iregex=r'^a'), + Article.objects.filter(headline='AbBa'), ) - self.assertQuerysetEqual(Article.objects.filter(headline__iregex=r'^a'), ['<Article: AbBa>']) # trailing anchor - self.assertQuerysetEqual(Article.objects.filter(headline__regex=r'z$'), ['<Article: baz>']) + self.assertQuerysetEqual( + Article.objects.filter(headline__regex=r'z$'), + Article.objects.filter(headline='baz'), + ) self.assertQuerysetEqual( Article.objects.filter(headline__iregex=r'z$'), - ['<Article: baxZ>', '<Article: baz>'] + Article.objects.filter(headline__in=['baxZ', 'baz']), ) # character sets self.assertQuerysetEqual( Article.objects.filter(headline__regex=r'ba[rz]'), - ['<Article: bar>', '<Article: baz>'] + 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__regex=r'ba.[RxZ]'), ['<Article: baxZ>']) self.assertQuerysetEqual( Article.objects.filter(headline__iregex=r'ba[RxZ]'), - ['<Article: bar>', '<Article: baxZ>', '<Article: baz>'] + Article.objects.filter(headline__in=['bar', 'baxZ', 'baz']), ) # and more articles: @@ -765,48 +706,48 @@ class LookupTests(TestCase): # alternation self.assertQuerysetEqual( Article.objects.filter(headline__regex=r'oo(f|b)'), - [ - '<Article: barfoobaz>', - '<Article: foobar>', - '<Article: foobarbaz>', - '<Article: foobaz>', - ] + Article.objects.filter(headline__in=[ + 'barfoobaz', + 'foobar', + 'foobarbaz', + 'foobaz', + ]), ) self.assertQuerysetEqual( Article.objects.filter(headline__iregex=r'oo(f|b)'), - [ - '<Article: barfoobaz>', - '<Article: foobar>', - '<Article: foobarbaz>', - '<Article: foobaz>', - '<Article: ooF>', - ] + Article.objects.filter(headline__in=[ + 'barfoobaz', + 'foobar', + 'foobarbaz', + 'foobaz', + 'ooF', + ]), ) self.assertQuerysetEqual( Article.objects.filter(headline__regex=r'^foo(f|b)'), - ['<Article: foobar>', '<Article: foobarbaz>', '<Article: foobaz>'] + Article.objects.filter(headline__in=['foobar', 'foobarbaz', 'foobaz']), ) # greedy matching self.assertQuerysetEqual( Article.objects.filter(headline__regex=r'b.*az'), - [ - '<Article: barfoobaz>', - '<Article: baz>', - '<Article: bazbaRFOO>', - '<Article: foobarbaz>', - '<Article: foobaz>', - ] + Article.objects.filter(headline__in=[ + 'barfoobaz', + 'baz', + 'bazbaRFOO', + 'foobarbaz', + 'foobaz', + ]), ) self.assertQuerysetEqual( Article.objects.filter(headline__iregex=r'b.*ar'), - [ - '<Article: bar>', - '<Article: barfoobaz>', - '<Article: bazbaRFOO>', - '<Article: foobar>', - '<Article: foobarbaz>', - ] + Article.objects.filter(headline__in=[ + 'bar', + 'barfoobaz', + 'bazbaRFOO', + 'foobar', + 'foobarbaz', + ]), ) @skipUnlessDBFeature('supports_regex_backreferencing') @@ -823,8 +764,8 @@ class LookupTests(TestCase): Article(pub_date=now, headline='bazbaRFOO'), ]) self.assertQuerysetEqual( - Article.objects.filter(headline__regex=r'b(.).*b\1'), - ['<Article: barfoobaz>', '<Article: bazbaRFOO>', '<Article: foobarbaz>'] + Article.objects.filter(headline__regex=r'b(.).*b\1').values_list('headline', flat=True), + ['barfoobaz', 'bazbaRFOO', 'foobarbaz'], ) def test_regex_null(self): @@ -838,8 +779,8 @@ class LookupTests(TestCase): """ A regex lookup does not fail on non-string fields """ - Season.objects.create(year=2013, gt=444) - self.assertQuerysetEqual(Season.objects.filter(gt__regex=r'^444$'), ['<Season: 2013>']) + s = Season.objects.create(year=2013, gt=444) + self.assertQuerysetEqual(Season.objects.filter(gt__regex=r'^444$'), [s]) def test_regex_non_ascii(self): """ @@ -928,31 +869,21 @@ class LookupTests(TestCase): self.assertEqual(Player.objects.filter(games__season__gt__gt=222).distinct().count(), 2) def test_chain_date_time_lookups(self): - self.assertQuerysetEqual( + self.assertCountEqual( Article.objects.filter(pub_date__month__gt=7), - ['<Article: Article 5>', '<Article: Article 6>'], - ordered=False + [self.a5, self.a6], ) - self.assertQuerysetEqual( + self.assertCountEqual( Article.objects.filter(pub_date__day__gte=27), - ['<Article: Article 2>', '<Article: Article 3>', - '<Article: Article 4>', '<Article: Article 7>'], - ordered=False + [self.a2, self.a3, self.a4, self.a7], ) - self.assertQuerysetEqual( + self.assertCountEqual( Article.objects.filter(pub_date__hour__lt=8), - ['<Article: Article 1>', '<Article: Article 2>', - '<Article: Article 3>', '<Article: Article 4>', - '<Article: Article 7>'], - ordered=False + [self.a1, self.a2, self.a3, self.a4, self.a7], ) - self.assertQuerysetEqual( + self.assertCountEqual( Article.objects.filter(pub_date__minute__lte=0), - ['<Article: Article 1>', '<Article: Article 2>', - '<Article: Article 3>', '<Article: Article 4>', - '<Article: Article 5>', '<Article: Article 6>', - '<Article: Article 7>'], - ordered=False + [self.a1, self.a2, self.a3, self.a4, self.a5, self.a6, self.a7], ) def test_exact_none_transform(self): diff --git a/tests/m2m_regress/tests.py b/tests/m2m_regress/tests.py index c27fd8a6b2..a2c7fc99cc 100644 --- a/tests/m2m_regress/tests.py +++ b/tests/m2m_regress/tests.py @@ -25,11 +25,11 @@ class M2MRegressionTests(TestCase): e1.topics.add(t1) e1.related.add(t2) - self.assertQuerysetEqual(s1.references.all(), ["<SelfRefer: s2>"]) - self.assertQuerysetEqual(s1.related.all(), ["<SelfRefer: s3>"]) + self.assertSequenceEqual(s1.references.all(), [s2]) + self.assertSequenceEqual(s1.related.all(), [s3]) - self.assertQuerysetEqual(e1.topics.all(), ["<Tag: t1>"]) - self.assertQuerysetEqual(e1.related.all(), ["<Tag: t2>"]) + 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 @@ -51,8 +51,8 @@ class M2MRegressionTests(TestCase): sr_sibling.save() sr_child.related.add(sr_sibling) - self.assertQuerysetEqual(sr_child.related.all(), ["<SelfRefer: Beth>"]) - self.assertQuerysetEqual(sr_sibling.related.all(), ["<SelfRefer: Hanna>"]) + 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 @@ -73,8 +73,8 @@ class M2MRegressionTests(TestCase): c1.tags.set([t1, t2]) c1 = TagCollection.objects.get(name='c1') - self.assertQuerysetEqual(c1.tags.all(), ["<Tag: t1>", "<Tag: t2>"], ordered=False) - self.assertQuerysetEqual(t1.tag_collections.all(), ["<TagCollection: 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() @@ -106,7 +106,7 @@ class M2MRegressionTests(TestCase): c1.tags.set(7) c1.refresh_from_db() - self.assertQuerysetEqual(c1.tags.order_by('name'), ["<Tag: t1>", "<Tag: t2>"]) + self.assertSequenceEqual(c1.tags.order_by('name'), [t1, t2]) def test_multiple_forwards_only_m2m(self): # Regression for #24505 - Multiple ManyToManyFields to same "to" @@ -116,5 +116,5 @@ class M2MRegressionTests(TestCase): post = Post.objects.create() post.primary_lines.add(foo) post.secondary_lines.add(bar) - self.assertQuerysetEqual(post.primary_lines.all(), ['<Line: foo>']) - self.assertQuerysetEqual(post.secondary_lines.all(), ['<Line: bar>']) + self.assertSequenceEqual(post.primary_lines.all(), [foo]) + self.assertSequenceEqual(post.secondary_lines.all(), [bar]) diff --git a/tests/m2m_through/tests.py b/tests/m2m_through/tests.py index ec3c481dd2..6262596dd0 100644 --- a/tests/m2m_through/tests.py +++ b/tests/m2m_through/tests.py @@ -42,20 +42,12 @@ class M2mThroughTests(TestCase): ) def test_filter_on_intermediate_model(self): - Membership.objects.create(person=self.jim, group=self.rock) - Membership.objects.create(person=self.jane, group=self.rock) + 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) - expected = [ - '<Membership: Jim is a member of Rock>', - '<Membership: Jane is a member of Rock>', - ] - - self.assertQuerysetEqual( - queryset, - expected - ) + 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.'}) @@ -372,12 +364,8 @@ class M2mThroughTests(TestCase): ) def test_custom_related_name_doesnt_conflict_with_fky_related_name(self): - CustomMembership.objects.create(person=self.bob, group=self.rock) - - self.assertQuerysetEqual( - self.bob.custom_person_related_name.all(), - ['<CustomMembership: Bob is a member of Rock>'] - ) + 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): """ diff --git a/tests/m2m_through_regress/tests.py b/tests/m2m_through_regress/tests.py index b0e12e2745..93d2260054 100644 --- a/tests/m2m_through_regress/tests.py +++ b/tests/m2m_through_regress/tests.py @@ -32,53 +32,31 @@ class M2MThroughTestCase(TestCase): cls.jane_rock = UserMembership.objects.create(user=cls.jane, group=cls.rock) def test_retrieve_reverse_m2m_items(self): - self.assertQuerysetEqual( - self.bob.group_set.all(), [ - "<Group: Rock>", - "<Group: Roll>", - ], - ordered=False - ) + self.assertCountEqual(self.bob.group_set.all(), [self.rock, self.roll]) def test_retrieve_forward_m2m_items(self): - self.assertQuerysetEqual( - self.roll.members.all(), [ - "<Person: Bob>", - ] - ) + self.assertSequenceEqual(self.roll.members.all(), [self.bob]) def test_retrieve_reverse_m2m_items_via_custom_id_intermediary(self): - self.assertQuerysetEqual( - self.frank.group_set.all(), [ - "<Group: Rock>", - "<Group: Roll>", - ], - ordered=False - ) + self.assertCountEqual(self.frank.group_set.all(), [self.rock, self.roll]) def test_retrieve_forward_m2m_items_via_custom_id_intermediary(self): - self.assertQuerysetEqual( - self.roll.user_members.all(), [ - "<User: frank>", - ] - ) + 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.assertQuerysetEqual( - self.rock.members.filter(membership__price=50), [ - "<Person: Jim>", - ] + self.assertSequenceEqual( + self.rock.members.filter(membership__price=50), + [self.jim], ) def test_join_trimming_reverse(self): - self.assertQuerysetEqual( - self.bob.group_set.filter(membership__price=50), [ - "<Group: Roll>", - ] + self.assertSequenceEqual( + self.bob.group_set.filter(membership__price=50), + [self.roll], ) @@ -139,26 +117,18 @@ class ToFieldThroughTests(TestCase): cls.unused_car2 = Car.objects.create(make="Wartburg") def test_to_field(self): - self.assertQuerysetEqual( - self.car.drivers.all(), - ["<Driver: Ryan Briscoe>"] - ) + self.assertSequenceEqual(self.car.drivers.all(), [self.driver]) def test_to_field_reverse(self): - self.assertQuerysetEqual( - self.driver.car_set.all(), - ["<Car: Toyota>"] - ) + self.assertSequenceEqual(self.driver.car_set.all(), [self.car]) def test_to_field_clear_reverse(self): self.driver.car_set.clear() - self.assertQuerysetEqual( - self.driver.car_set.all(), []) + self.assertSequenceEqual(self.driver.car_set.all(), []) def test_to_field_clear(self): self.car.drivers.clear() - self.assertQuerysetEqual( - self.car.drivers.all(), []) + 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 @@ -166,15 +136,12 @@ class ToFieldThroughTests(TestCase): # 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.assertQuerysetEqual( - self.car.drivers.all(), - ["<Driver: Ryan Briscoe>"] - ) + 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.assertQuerysetEqual( + self.assertSequenceEqual( self.car.drivers.all(), - ["<Driver: Barney Gumble>", "<Driver: Ryan Briscoe>"] + [self.unused_driver, self.driver], ) def test_m2m_relations_unusable_on_null_to_field(self): @@ -202,16 +169,9 @@ class ToFieldThroughTests(TestCase): def test_add_reverse(self): car2 = Car.objects.create(make="Honda") - self.assertQuerysetEqual( - self.driver.car_set.all(), - ["<Car: Toyota>"] - ) + self.assertCountEqual(self.driver.car_set.all(), [self.car]) self.driver.car_set._add_items('driver', 'car', car2) - self.assertQuerysetEqual( - self.driver.car_set.all(), - ["<Car: Toyota>", "<Car: Honda>"], - ordered=False - ) + self.assertCountEqual(self.driver.car_set.all(), [self.car, car2]) def test_add_null_reverse(self): nullcar = Car.objects.create(make=None) @@ -229,22 +189,14 @@ class ToFieldThroughTests(TestCase): nulldriver.car_set._add_items('driver', 'car', self.car) def test_remove(self): - self.assertQuerysetEqual( - self.car.drivers.all(), - ["<Driver: Ryan Briscoe>"] - ) + self.assertSequenceEqual(self.car.drivers.all(), [self.driver]) self.car.drivers._remove_items('car', 'driver', self.driver) - self.assertQuerysetEqual( - self.car.drivers.all(), []) + self.assertSequenceEqual(self.car.drivers.all(), []) def test_remove_reverse(self): - self.assertQuerysetEqual( - self.driver.car_set.all(), - ["<Car: Toyota>"] - ) + self.assertSequenceEqual(self.driver.car_set.all(), [self.car]) self.driver.car_set._remove_items('driver', 'car', self.car) - self.assertQuerysetEqual( - self.driver.car_set.all(), []) + self.assertSequenceEqual(self.driver.car_set.all(), []) class ThroughLoadDataTestCase(TestCase): diff --git a/tests/m2o_recursive/tests.py b/tests/m2o_recursive/tests.py index 95b60a8e49..1b9a72a796 100644 --- a/tests/m2o_recursive/tests.py +++ b/tests/m2o_recursive/tests.py @@ -11,11 +11,10 @@ class ManyToOneRecursiveTests(TestCase): cls.c = Category.objects.create(id=None, name='Child category', parent=cls.r) def test_m2o_recursive(self): - self.assertQuerysetEqual(self.r.child_set.all(), - ['<Category: Child category>']) + 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.assertQuerysetEqual(self.c.child_set.all(), []) + self.assertSequenceEqual(self.c.child_set.all(), []) self.assertEqual(self.c.parent.id, self.r.id) @@ -30,9 +29,7 @@ class MultipleManyToOneRecursiveTests(TestCase): def test_m2o_recursive2(self): self.assertEqual(self.kid.mother.id, self.mom.id) self.assertEqual(self.kid.father.id, self.dad.id) - self.assertQuerysetEqual(self.dad.fathers_child_set.all(), - ['<Person: John Smith Junior>']) - self.assertQuerysetEqual(self.mom.mothers_child_set.all(), - ['<Person: John Smith Junior>']) - self.assertQuerysetEqual(self.kid.mothers_child_set.all(), []) - self.assertQuerysetEqual(self.kid.fathers_child_set.all(), []) + 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/tests/managers_regress/tests.py b/tests/managers_regress/tests.py index 7fa6815959..421e30ca45 100644 --- a/tests/managers_regress/tests.py +++ b/tests/managers_regress/tests.py @@ -14,46 +14,44 @@ from .models import ( class ManagersRegressionTests(TestCase): def test_managers(self): - Child1.objects.create(name='fred', data='a1') - Child1.objects.create(name='barney', data='a2') - Child2.objects.create(name='fred', data='b1', value=1) - Child2.objects.create(name='barney', data='b2', value=42) - Child3.objects.create(name='fred', data='c1', comment='yes') - Child3.objects.create(name='barney', data='c2', comment='no') - Child4.objects.create(name='fred', data='d1') - Child4.objects.create(name='barney', data='d2') - Child5.objects.create(name='fred', comment='yes') + 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') - Child6.objects.create(name='fred', data='f1', value=42) - Child6.objects.create(name='barney', data='f2', value=42) - Child7.objects.create(name='fred') - Child7.objects.create(name='barney') + 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.assertQuerysetEqual(Child1.manager1.all(), ["<Child1: a1>"]) - self.assertQuerysetEqual(Child1.manager2.all(), ["<Child1: a2>"]) - self.assertQuerysetEqual(Child1._default_manager.all(), ["<Child1: a1>"]) + self.assertSequenceEqual(Child1.manager1.all(), [a1]) + self.assertSequenceEqual(Child1.manager2.all(), [a2]) + self.assertSequenceEqual(Child1._default_manager.all(), [a1]) - self.assertQuerysetEqual(Child2._default_manager.all(), ["<Child2: b1>"]) - self.assertQuerysetEqual(Child2.restricted.all(), ["<Child2: b2>"]) + self.assertSequenceEqual(Child2._default_manager.all(), [b1]) + self.assertSequenceEqual(Child2.restricted.all(), [b2]) - self.assertQuerysetEqual(Child3._default_manager.all(), ["<Child3: c1>"]) - self.assertQuerysetEqual(Child3.manager1.all(), ["<Child3: c1>"]) - self.assertQuerysetEqual(Child3.manager2.all(), ["<Child3: c2>"]) + 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.assertQuerysetEqual(Child4._default_manager.order_by('data'), [ - "<Child4: d1>", - "<Child4: d2>", - "<Child4: f1>", - "<Child4: f2>", - ]) - self.assertQuerysetEqual(Child4.manager1.all(), ["<Child4: d1>", "<Child4: f1>"], ordered=False) - self.assertQuerysetEqual(Child5._default_manager.all(), ["<Child5: fred>"]) - self.assertQuerysetEqual(Child6._default_manager.all(), ["<Child6: f1>", "<Child6: f2>"], ordered=False) - self.assertQuerysetEqual( + 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'), - ["<Child7: barney>", "<Child7: fred>"] + [barney, fred2], ) def test_abstract_manager(self): diff --git a/tests/many_to_many/tests.py b/tests/many_to_many/tests.py index 1359cf0773..9242be9a9f 100644 --- a/tests/many_to_many/tests.py +++ b/tests/many_to_many/tests.py @@ -44,7 +44,7 @@ class ManyToManyTests(TestCase): a5.save() # Associate the Article with a Publication. a5.publications.add(self.p1) - self.assertQuerysetEqual(a5.publications.all(), ['<Publication: The Python Journal>']) + 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() @@ -52,13 +52,9 @@ class ManyToManyTests(TestCase): a6.publications.add(self.p3) # Adding a second time is OK a6.publications.add(self.p3) - self.assertQuerysetEqual( + self.assertSequenceEqual( a6.publications.all(), - [ - '<Publication: Science News>', - '<Publication: Science Weekly>', - '<Publication: The Python Journal>', - ] + [self.p2, self.p3, self.p1], ) # Adding an object of the wrong type raises TypeError @@ -68,42 +64,31 @@ class ManyToManyTests(TestCase): a6.publications.add(a5) # Add a Publication directly via publications.add by using keyword arguments. - a6.publications.create(title='Highlights for Adults') - self.assertQuerysetEqual( + p5 = a6.publications.create(title='Highlights for Adults') + self.assertSequenceEqual( a6.publications.all(), - [ - '<Publication: Highlights for Adults>', - '<Publication: Science News>', - '<Publication: Science Weekly>', - '<Publication: The Python Journal>', - ] + [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.assertQuerysetEqual( - a5.publications.all(), - ['<Publication: The Python Journal>'], - ) + self.assertSequenceEqual(a5.publications.all(), [self.p1]) a5.publications.set([self.p2.pk]) - self.assertQuerysetEqual( - a5.publications.all(), - ['<Publication: Science News>'], - ) + self.assertSequenceEqual(a5.publications.all(), [self.p2]) a5.publications.remove(self.p2.pk) - self.assertQuerysetEqual(a5.publications.all(), []) + 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.assertQuerysetEqual(a5.authors.all(), ['<User: Jean>']) + self.assertSequenceEqual(a5.authors.all(), [user_1]) a5.authors.set([user_2.username]) - self.assertQuerysetEqual(a5.authors.all(), ['<User: Joe>']) + self.assertSequenceEqual(a5.authors.all(), [user_2]) a5.authors.remove(user_2.username) - self.assertQuerysetEqual(a5.authors.all(), []) + self.assertSequenceEqual(a5.authors.all(), []) def test_add_remove_invalid_type(self): msg = "Field 'id' expected a number but got 'invalid'." @@ -116,37 +101,22 @@ class ManyToManyTests(TestCase): a5 = Article(headline='NASA finds intelligent life on Mars') a5.save() self.p2.article_set.add(a5) - self.assertQuerysetEqual( + self.assertSequenceEqual( self.p2.article_set.all(), - [ - '<Article: NASA finds intelligent life on Earth>', - '<Article: NASA finds intelligent life on Mars>', - '<Article: NASA uses Python>', - '<Article: Oxygen-free diet works wonders>', - ] + [self.a3, a5, self.a2, self.a4], ) - self.assertQuerysetEqual(a5.publications.all(), ['<Publication: Science News>']) + self.assertSequenceEqual(a5.publications.all(), [self.p2]) # Adding via the other end using keywords - self.p2.article_set.create(headline='Carbon-free diet works wonders') - self.assertQuerysetEqual( + a6 = self.p2.article_set.create(headline='Carbon-free diet works wonders') + self.assertSequenceEqual( self.p2.article_set.all(), - [ - '<Article: Carbon-free diet works wonders>', - '<Article: NASA finds intelligent life on Earth>', - '<Article: NASA finds intelligent life on Mars>', - '<Article: NASA uses Python>', - '<Article: Oxygen-free diet works wonders>', - ]) + [a6, self.a3, a5, self.a2, self.a4], + ) a6 = self.p2.article_set.all()[3] - self.assertQuerysetEqual( + self.assertSequenceEqual( a6.publications.all(), - [ - '<Publication: Highlights for Children>', - '<Publication: Science News>', - '<Publication: Science Weekly>', - '<Publication: The Python Journal>', - ] + [self.p4, self.p2, self.p3, self.p1], ) @skipUnlessDBFeature('supports_ignore_conflicts') @@ -182,293 +152,195 @@ class ManyToManyTests(TestCase): def test_related_sets(self): # Article objects have access to their related Publication objects. - self.assertQuerysetEqual(self.a1.publications.all(), ['<Publication: The Python Journal>']) - self.assertQuerysetEqual( + self.assertSequenceEqual(self.a1.publications.all(), [self.p1]) + self.assertSequenceEqual( self.a2.publications.all(), - [ - '<Publication: Highlights for Children>', - '<Publication: Science News>', - '<Publication: Science Weekly>', - '<Publication: The Python Journal>', - ] + [self.p4, self.p2, self.p3, self.p1], ) # Publication objects have access to their related Article objects. - self.assertQuerysetEqual( + self.assertSequenceEqual( self.p2.article_set.all(), - [ - '<Article: NASA finds intelligent life on Earth>', - '<Article: NASA uses Python>', - '<Article: Oxygen-free diet works wonders>', - ] + [self.a3, self.a2, self.a4], ) - self.assertQuerysetEqual( + self.assertSequenceEqual( self.p1.article_set.all(), - [ - '<Article: Django lets you build Web apps easily>', - '<Article: NASA uses Python>', - ] + [self.a1, self.a2], ) - self.assertQuerysetEqual( + self.assertSequenceEqual( Publication.objects.get(id=self.p4.id).article_set.all(), - ['<Article: NASA uses Python>'] + [self.a2], ) def test_selects(self): # We can perform kwarg queries across m2m relationships - self.assertQuerysetEqual( + self.assertSequenceEqual( Article.objects.filter(publications__id__exact=self.p1.id), - [ - '<Article: Django lets you build Web apps easily>', - '<Article: NASA uses Python>', - ]) - self.assertQuerysetEqual( + [self.a1, self.a2], + ) + self.assertSequenceEqual( Article.objects.filter(publications__pk=self.p1.id), - [ - '<Article: Django lets you build Web apps easily>', - '<Article: NASA uses Python>', - ] + [self.a1, self.a2], ) - self.assertQuerysetEqual( + self.assertSequenceEqual( Article.objects.filter(publications=self.p1.id), - [ - '<Article: Django lets you build Web apps easily>', - '<Article: NASA uses Python>', - ] + [self.a1, self.a2], ) - self.assertQuerysetEqual( + self.assertSequenceEqual( Article.objects.filter(publications=self.p1), - [ - '<Article: Django lets you build Web apps easily>', - '<Article: NASA uses Python>', - ] + [self.a1, self.a2], ) - self.assertQuerysetEqual( + self.assertSequenceEqual( Article.objects.filter(publications__title__startswith="Science"), - [ - '<Article: NASA finds intelligent life on Earth>', - '<Article: NASA uses Python>', - '<Article: NASA uses Python>', - '<Article: Oxygen-free diet works wonders>', - ] - ) - self.assertQuerysetEqual( + [self.a3, self.a2, self.a2, self.a4] + ) + self.assertSequenceEqual( Article.objects.filter(publications__title__startswith="Science").distinct(), - [ - '<Article: NASA finds intelligent life on Earth>', - '<Article: NASA uses Python>', - '<Article: Oxygen-free diet works wonders>', - ] + [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.assertQuerysetEqual( + self.assertSequenceEqual( Article.objects.filter(publications__in=[self.p1.id, self.p2.id]).distinct(), - [ - '<Article: Django lets you build Web apps easily>', - '<Article: NASA finds intelligent life on Earth>', - '<Article: NASA uses Python>', - '<Article: Oxygen-free diet works wonders>', - ]) - self.assertQuerysetEqual( + [self.a1, self.a3, self.a2, self.a4], + ) + self.assertSequenceEqual( Article.objects.filter(publications__in=[self.p1.id, self.p2]).distinct(), - [ - '<Article: Django lets you build Web apps easily>', - '<Article: NASA finds intelligent life on Earth>', - '<Article: NASA uses Python>', - '<Article: Oxygen-free diet works wonders>', - ] - ) - self.assertQuerysetEqual( + [self.a1, self.a3, self.a2, self.a4], + ) + self.assertSequenceEqual( Article.objects.filter(publications__in=[self.p1, self.p2]).distinct(), - [ - '<Article: Django lets you build Web apps easily>', - '<Article: NASA finds intelligent life on Earth>', - '<Article: NASA uses Python>', - '<Article: Oxygen-free diet works wonders>', - ] + [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.assertQuerysetEqual( + self.assertSequenceEqual( Article.objects.exclude(publications=self.p2), - ['<Article: Django lets you build Web apps easily>'] + [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 = ['<Publication: The Python Journal>'] - self.assertQuerysetEqual(Publication.objects.filter(id__exact=self.p1.id), python_journal) - self.assertQuerysetEqual(Publication.objects.filter(pk=self.p1.id), python_journal) - self.assertQuerysetEqual( + 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"), - [ - '<Publication: Highlights for Children>', - '<Publication: Science News>', - '<Publication: Science News>', - '<Publication: Science Weekly>', - '<Publication: The Python Journal>', - ]) - - self.assertQuerysetEqual(Publication.objects.filter(article__id__exact=self.a1.id), python_journal) - self.assertQuerysetEqual(Publication.objects.filter(article__pk=self.a1.id), python_journal) - self.assertQuerysetEqual(Publication.objects.filter(article=self.a1.id), python_journal) - self.assertQuerysetEqual(Publication.objects.filter(article=self.a1), python_journal) - - self.assertQuerysetEqual( + [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(), - [ - '<Publication: Highlights for Children>', - '<Publication: Science News>', - '<Publication: Science Weekly>', - '<Publication: The Python Journal>', - ]) - self.assertQuerysetEqual( + [self.p4, self.p2, self.p3, self.p1], + ) + self.assertSequenceEqual( Publication.objects.filter(article__in=[self.a1.id, self.a2]).distinct(), - [ - '<Publication: Highlights for Children>', - '<Publication: Science News>', - '<Publication: Science Weekly>', - '<Publication: The Python Journal>', - ]) - self.assertQuerysetEqual( + [self.p4, self.p2, self.p3, self.p1], + ) + self.assertSequenceEqual( Publication.objects.filter(article__in=[self.a1, self.a2]).distinct(), - [ - '<Publication: Highlights for Children>', - '<Publication: Science News>', - '<Publication: Science Weekly>', - '<Publication: The Python Journal>', - ]) + [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.assertQuerysetEqual( + self.assertSequenceEqual( Publication.objects.all(), - [ - '<Publication: Highlights for Children>', - '<Publication: Science News>', - '<Publication: Science Weekly>', - ] + [self.p4, self.p2, self.p3], ) - self.assertQuerysetEqual(self.a1.publications.all(), []) + self.assertSequenceEqual(self.a1.publications.all(), []) # If we delete an Article, its Publications won't be able to access it. self.a2.delete() - self.assertQuerysetEqual( + self.assertSequenceEqual( Article.objects.all(), - [ - '<Article: Django lets you build Web apps easily>', - '<Article: NASA finds intelligent life on Earth>', - '<Article: Oxygen-free diet works wonders>', - ] + [self.a1, self.a3, self.a4], ) - self.assertQuerysetEqual( + self.assertSequenceEqual( self.p2.article_set.all(), - [ - '<Article: NASA finds intelligent life on Earth>', - '<Article: Oxygen-free diet works wonders>', - ] + [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.assertQuerysetEqual( + self.assertSequenceEqual( Publication.objects.all(), - [ - '<Publication: Highlights for Children>', - '<Publication: The Python Journal>', - ] + [self.p4, self.p1], ) - self.assertQuerysetEqual( + self.assertSequenceEqual( Article.objects.all(), - [ - '<Article: Django lets you build Web apps easily>', - '<Article: NASA finds intelligent life on Earth>', - '<Article: NASA uses Python>', - '<Article: Oxygen-free diet works wonders>', - ] - ) - self.assertQuerysetEqual( + [self.a1, self.a3, self.a2, self.a4], + ) + self.assertSequenceEqual( self.a2.publications.all(), - [ - '<Publication: Highlights for Children>', - '<Publication: The Python Journal>', - ] + [self.p4, self.p1], ) # Bulk delete some articles - references to deleted objects should go q = Article.objects.filter(headline__startswith='Django') - self.assertQuerysetEqual(q, ['<Article: Django lets you build Web apps easily>']) + 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.assertQuerysetEqual(q, []) - self.assertQuerysetEqual(self.p1.article_set.all(), ['<Article: NASA uses Python>']) + self.assertSequenceEqual(q, []) + self.assertSequenceEqual(self.p1.article_set.all(), [self.a2]) def test_remove(self): # Removing publication from an article: - self.assertQuerysetEqual( + self.assertSequenceEqual( self.p2.article_set.all(), - [ - '<Article: NASA finds intelligent life on Earth>', - '<Article: NASA uses Python>', - '<Article: Oxygen-free diet works wonders>', - ] + [self.a3, self.a2, self.a4], ) self.a4.publications.remove(self.p2) - self.assertQuerysetEqual( + self.assertSequenceEqual( self.p2.article_set.all(), - [ - '<Article: NASA finds intelligent life on Earth>', - '<Article: NASA uses Python>', - ] + [self.a3, self.a2], ) - self.assertQuerysetEqual(self.a4.publications.all(), []) + self.assertSequenceEqual(self.a4.publications.all(), []) # And from the other end self.p2.article_set.remove(self.a3) - self.assertQuerysetEqual(self.p2.article_set.all(), ['<Article: NASA uses Python>']) - self.assertQuerysetEqual(self.a3.publications.all(), []) + 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.assertQuerysetEqual( + self.assertSequenceEqual( self.p2.article_set.all(), - [ - '<Article: NASA finds intelligent life on Earth>', - '<Article: Oxygen-free diet works wonders>', - ] + [self.a3, self.a4], ) - self.assertQuerysetEqual(self.a4.publications.all(), ['<Publication: Science News>']) + self.assertSequenceEqual(self.a4.publications.all(), [self.p2]) self.a4.publications.set([self.p3.id]) - self.assertQuerysetEqual(self.p2.article_set.all(), ['<Article: NASA finds intelligent life on Earth>']) - self.assertQuerysetEqual(self.a4.publications.all(), ['<Publication: Science Weekly>']) + self.assertSequenceEqual(self.p2.article_set.all(), [self.a3]) + self.assertSequenceEqual(self.a4.publications.all(), [self.p3]) self.p2.article_set.set([]) - self.assertQuerysetEqual(self.p2.article_set.all(), []) + self.assertSequenceEqual(self.p2.article_set.all(), []) self.a4.publications.set([]) - self.assertQuerysetEqual(self.a4.publications.all(), []) + self.assertSequenceEqual(self.a4.publications.all(), []) self.p2.article_set.set([self.a4, self.a3], clear=True) - self.assertQuerysetEqual( + self.assertSequenceEqual( self.p2.article_set.all(), - [ - '<Article: NASA finds intelligent life on Earth>', - '<Article: Oxygen-free diet works wonders>', - ] + [self.a3, self.a4], ) - self.assertQuerysetEqual(self.a4.publications.all(), ['<Publication: Science News>']) + self.assertSequenceEqual(self.a4.publications.all(), [self.p2]) self.a4.publications.set([self.p3.id], clear=True) - self.assertQuerysetEqual(self.p2.article_set.all(), ['<Article: NASA finds intelligent life on Earth>']) - self.assertQuerysetEqual(self.a4.publications.all(), ['<Publication: Science Weekly>']) + 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.assertQuerysetEqual(self.p2.article_set.all(), []) + self.assertSequenceEqual(self.p2.article_set.all(), []) self.a4.publications.set([], clear=True) - self.assertQuerysetEqual(self.a4.publications.all(), []) + self.assertSequenceEqual(self.a4.publications.all(), []) def test_set_existing_different_type(self): # Existing many-to-many relations remain the same for values provided @@ -502,37 +374,32 @@ class ManyToManyTests(TestCase): def test_assign(self): # Relation sets can be assigned using set(). self.p2.article_set.set([self.a4, self.a3]) - self.assertQuerysetEqual( - self.p2.article_set.all(), [ - '<Article: NASA finds intelligent life on Earth>', - '<Article: Oxygen-free diet works wonders>', - ] + self.assertSequenceEqual( + self.p2.article_set.all(), + [self.a3, self.a4], ) - self.assertQuerysetEqual(self.a4.publications.all(), ['<Publication: Science News>']) + self.assertSequenceEqual(self.a4.publications.all(), [self.p2]) self.a4.publications.set([self.p3.id]) - self.assertQuerysetEqual(self.p2.article_set.all(), ['<Article: NASA finds intelligent life on Earth>']) - self.assertQuerysetEqual(self.a4.publications.all(), ['<Publication: Science Weekly>']) + 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.assertQuerysetEqual(self.p2.article_set.all(), []) + self.assertSequenceEqual(self.p2.article_set.all(), []) self.a4.publications.set([]) - self.assertQuerysetEqual(self.a4.publications.all(), []) + 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.assertQuerysetEqual( + self.assertSequenceEqual( self.p2.article_set.all(), - [ - '<Article: NASA finds intelligent life on Earth>', - '<Article: Oxygen-free diet works wonders>', - ] + [self.a3, self.a4], ) - self.assertQuerysetEqual(self.a4.publications.all(), ['<Publication: Science News>']) + self.assertSequenceEqual(self.a4.publications.all(), [self.p2]) self.a4.publications.set([self.p3.id]) - self.assertQuerysetEqual(self.p2.article_set.all(), ['<Article: NASA finds intelligent life on Earth>']) - self.assertQuerysetEqual(self.a4.publications.all(), ['<Publication: Science Weekly>']) + 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 @@ -561,34 +428,31 @@ class ManyToManyTests(TestCase): def test_clear(self): # Relation sets can be cleared: self.p2.article_set.clear() - self.assertQuerysetEqual(self.p2.article_set.all(), []) - self.assertQuerysetEqual(self.a4.publications.all(), []) + 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.assertQuerysetEqual( + self.assertSequenceEqual( self.p2.article_set.all(), - [ - '<Article: NASA finds intelligent life on Earth>', - '<Article: Oxygen-free diet works wonders>', - ] + [self.a3, self.a4], ) - self.assertQuerysetEqual(self.a4.publications.all(), ['<Publication: Science News>']) + self.assertSequenceEqual(self.a4.publications.all(), [self.p2]) self.a4.publications.clear() - self.assertQuerysetEqual(self.a4.publications.all(), []) - self.assertQuerysetEqual(self.p2.article_set.all(), ['<Article: NASA finds intelligent life on Earth>']) + 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.assertQuerysetEqual(a4.publications.all(), ['<Publication: Science News>']) + self.assertSequenceEqual(a4.publications.all(), [self.p2]) a4.publications.clear() - self.assertQuerysetEqual(a4.publications.all(), []) + self.assertSequenceEqual(a4.publications.all(), []) def test_remove_after_prefetch(self): a4 = Article.objects.prefetch_related('publications').get(id=self.a4.id) - self.assertQuerysetEqual(a4.publications.all(), ['<Publication: Science News>']) + self.assertSequenceEqual(a4.publications.all(), [self.p2]) a4.publications.remove(self.p2) - self.assertQuerysetEqual(a4.publications.all(), []) + self.assertSequenceEqual(a4.publications.all(), []) def test_add_after_prefetch(self): a4 = Article.objects.prefetch_related('publications').get(id=self.a4.id) @@ -610,7 +474,7 @@ class ManyToManyTests(TestCase): a4.publications.add(self.p1) self.assertEqual(a4.publications.count(), 2) a4.publications.remove(self.p1) - self.assertQuerysetEqual(a4.publications.all(), ['<Publication: Science News>']) + self.assertSequenceEqual(a4.publications.all(), [self.p2]) def test_inherited_models_selects(self): """ @@ -620,22 +484,17 @@ class ManyToManyTests(TestCase): a = InheritedArticleA.objects.create() b = InheritedArticleB.objects.create() a.publications.add(self.p1, self.p2) - self.assertQuerysetEqual( + self.assertSequenceEqual( a.publications.all(), - [ - '<Publication: Science News>', - '<Publication: The Python Journal>', - ]) - self.assertQuerysetEqual(b.publications.all(), []) + [self.p2, self.p1], + ) + self.assertSequenceEqual(b.publications.all(), []) b.publications.add(self.p3) - self.assertQuerysetEqual( + self.assertSequenceEqual( a.publications.all(), - [ - '<Publication: Science News>', - '<Publication: The Python Journal>', - ] + [self.p2, self.p1], ) - self.assertQuerysetEqual(b.publications.all(), ['<Publication: Science Weekly>']) + self.assertSequenceEqual(b.publications.all(), [self.p3]) def test_custom_default_manager_exists_count(self): a5 = Article.objects.create(headline='deleted') diff --git a/tests/many_to_one/tests.py b/tests/many_to_one/tests.py index e1bfa0dcf6..0687133de4 100644 --- a/tests/many_to_one/tests.py +++ b/tests/many_to_one/tests.py @@ -57,23 +57,23 @@ class ManyToOneTests(TestCase): self.r.article_set.add(new_article2, bulk=False) self.assertEqual(new_article2.reporter.id, self.r.id) - self.assertQuerysetEqual( + self.assertSequenceEqual( self.r.article_set.all(), - ["<Article: John's second story>", "<Article: Paul's story>", "<Article: This is a test>"] + [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.assertQuerysetEqual(self.r2.article_set.all(), ["<Article: Paul's story>"]) + self.assertSequenceEqual(self.r2.article_set.all(), [new_article2]) # Adding an object of the wrong type raises TypeError. with transaction.atomic(): with self.assertRaisesMessage(TypeError, "'Article' instance expected, got <Reporter:"): self.r.article_set.add(self.r2) - self.assertQuerysetEqual( + self.assertSequenceEqual( self.r.article_set.all(), - ["<Article: John's second story>", "<Article: This is a test>"] + [new_article, self.a], ) def test_set(self): @@ -85,29 +85,28 @@ class ManyToOneTests(TestCase): new_article2.save() self.assertEqual(repr(new_article2.reporter), "<Reporter: John Smith>") self.assertEqual(new_article2.reporter.id, self.r.id) - self.assertQuerysetEqual(self.r.article_set.all(), [ - "<Article: John's second story>", - "<Article: Paul's story>", - "<Article: This is a test>", - ]) - self.assertQuerysetEqual(self.r2.article_set.all(), []) + 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.assertQuerysetEqual(self.r.article_set.all(), ["<Article: This is a test>"]) - self.assertQuerysetEqual( + self.assertSequenceEqual(self.r.article_set.all(), [self.a]) + self.assertSequenceEqual( self.r2.article_set.all(), - ["<Article: John's second story>", "<Article: Paul's story>"] + [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.assertQuerysetEqual( + self.assertSequenceEqual( self.r.article_set.all(), - ["<Article: John's second story>", "<Article: This is a test>"] + [new_article, self.a], ) - self.assertQuerysetEqual(self.r2.article_set.all(), ["<Article: Paul's story>"]) + self.assertSequenceEqual(self.r2.article_set.all(), [new_article2]) def test_reverse_assignment_deprecation(self): msg = ( @@ -126,29 +125,28 @@ class ManyToOneTests(TestCase): new_article2.save() self.assertEqual(repr(new_article2.reporter), "<Reporter: John Smith>") self.assertEqual(new_article2.reporter.id, self.r.id) - self.assertQuerysetEqual(self.r.article_set.all(), [ - "<Article: John's second story>", - "<Article: Paul's story>", - "<Article: This is a test>", - ]) - self.assertQuerysetEqual(self.r2.article_set.all(), []) + 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.assertQuerysetEqual(self.r.article_set.all(), ["<Article: This is a test>"]) - self.assertQuerysetEqual( + self.assertSequenceEqual(self.r.article_set.all(), [self.a]) + self.assertSequenceEqual( self.r2.article_set.all(), - ["<Article: John's second story>", "<Article: Paul's story>"] + [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.assertQuerysetEqual( + self.assertSequenceEqual( self.r.article_set.all(), - ["<Article: John's second story>", "<Article: This is a test>"] + [new_article, self.a], ) - self.assertQuerysetEqual(self.r2.article_set.all(), ["<Article: Paul's story>"]) + 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')) @@ -182,38 +180,44 @@ class ManyToOneTests(TestCase): self.assertTrue(Parent.bestchild.is_cached(parent)) def test_selects(self): - self.r.article_set.create(headline="John's second story", pub_date=datetime.date(2005, 7, 29)) - self.r2.article_set.create(headline="Paul's story", pub_date=datetime.date(2006, 1, 17)) + 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.assertQuerysetEqual(self.r.article_set.all(), [ - "<Article: John's second story>", - "<Article: This is a test>", - ]) - self.assertQuerysetEqual(self.r.article_set.filter(headline__startswith='This'), ["<Article: This is a test>"]) + 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.assertQuerysetEqual(Article.objects.filter(id__exact=self.a.id), ["<Article: This is a test>"]) - self.assertQuerysetEqual(Article.objects.filter(pk=self.a.id), ["<Article: This is a test>"]) + 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.assertQuerysetEqual(Article.objects.filter(headline__startswith='This'), ["<Article: This is a test>"]) + 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.assertQuerysetEqual( + self.assertSequenceEqual( Article.objects.filter(reporter__first_name__exact='John'), - ["<Article: John's second story>", "<Article: This is a test>"] + [new_article1, self.a], ) # Implied __exact also works - self.assertQuerysetEqual( + self.assertSequenceEqual( Article.objects.filter(reporter__first_name='John'), - ["<Article: John's second story>", "<Article: This is a test>"] + [new_article1, self.a], ) # Query twice over the related field. - self.assertQuerysetEqual( + self.assertSequenceEqual( Article.objects.filter(reporter__first_name__exact='John', reporter__last_name__exact='Smith'), - ["<Article: John's second story>", "<Article: This is a test>"] + [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') @@ -221,69 +225,53 @@ class ManyToOneTests(TestCase): self.assertEqual(queryset.query.get_compiler(queryset.db).as_sql()[0].count('INNER JOIN'), 1) # The automatically joined table has a predictable name. - self.assertQuerysetEqual( + self.assertSequenceEqual( Article.objects.filter(reporter__first_name__exact='John').extra( where=["many_to_one_reporter.last_name='Smith'"]), - ["<Article: John's second story>", "<Article: This is a test>"] + [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'])), - ["<Article: John's second story>", "<Article: This is a test>"] + [new_article1, self.a] ) # Find all Articles for a Reporter. # Use direct ID check, pk check, and object comparison - self.assertQuerysetEqual( + self.assertSequenceEqual( Article.objects.filter(reporter__id__exact=self.r.id), - [ - "<Article: John's second story>", - "<Article: This is a test>", - ]) - self.assertQuerysetEqual( + [new_article1, self.a], + ) + self.assertSequenceEqual( Article.objects.filter(reporter__pk=self.r.id), - [ - "<Article: John's second story>", - "<Article: This is a test>", - ]) - self.assertQuerysetEqual( + [new_article1, self.a], + ) + self.assertSequenceEqual( Article.objects.filter(reporter=self.r.id), - [ - "<Article: John's second story>", - "<Article: This is a test>", - ]) - self.assertQuerysetEqual( + [new_article1, self.a], + ) + self.assertSequenceEqual( Article.objects.filter(reporter=self.r), - [ - "<Article: John's second story>", - "<Article: This is a test>", - ]) - self.assertQuerysetEqual( + [new_article1, self.a], + ) + self.assertSequenceEqual( Article.objects.filter(reporter__in=[self.r.id, self.r2.id]).distinct(), - [ - "<Article: John's second story>", - "<Article: Paul's story>", - "<Article: This is a test>", - ]) - self.assertQuerysetEqual( + [new_article1, new_article2, self.a], + ) + self.assertSequenceEqual( Article.objects.filter(reporter__in=[self.r, self.r2]).distinct(), - [ - "<Article: John's second story>", - "<Article: Paul's story>", - "<Article: This is a test>", - ]) + [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.assertQuerysetEqual( + self.assertSequenceEqual( Article.objects.filter( reporter__in=Reporter.objects.filter(first_name='John').values('pk').query ).distinct(), - [ - "<Article: John's second story>", - "<Article: This is a test>", - ]) + [new_article1, self.a], + ) def test_reverse_selects(self): a3 = Article.objects.create( @@ -296,48 +284,42 @@ class ManyToOneTests(TestCase): pub_date=datetime.date(2005, 7, 27), reporter_id=self.r.id, ) - john_smith = ["<Reporter: John Smith>"] + john_smith = [self.r] # Reporters can be queried - self.assertQuerysetEqual(Reporter.objects.filter(id__exact=self.r.id), john_smith) - self.assertQuerysetEqual(Reporter.objects.filter(pk=self.r.id), john_smith) - self.assertQuerysetEqual(Reporter.objects.filter(first_name__startswith='John'), john_smith) + 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.assertQuerysetEqual(Reporter.objects.filter(article__id__exact=self.a.id), john_smith) - self.assertQuerysetEqual(Reporter.objects.filter(article__pk=self.a.id), john_smith) - self.assertQuerysetEqual(Reporter.objects.filter(article=self.a.id), john_smith) - self.assertQuerysetEqual(Reporter.objects.filter(article=self.a), john_smith) - self.assertQuerysetEqual(Reporter.objects.filter(article__in=[self.a.id, a3.id]).distinct(), john_smith) - self.assertQuerysetEqual(Reporter.objects.filter(article__in=[self.a.id, a3]).distinct(), john_smith) - self.assertQuerysetEqual(Reporter.objects.filter(article__in=[self.a, a3]).distinct(), john_smith) - self.assertQuerysetEqual( + 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'), - ["<Reporter: John Smith>", "<Reporter: John Smith>"], - ordered=False + [self.r, self.r], ) - self.assertQuerysetEqual(Reporter.objects.filter(article__headline__startswith='T').distinct(), john_smith) + 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.assertQuerysetEqual( + self.assertCountEqual( Reporter.objects.filter(article__reporter__first_name__startswith='John'), - [ - "<Reporter: John Smith>", - "<Reporter: John Smith>", - "<Reporter: John Smith>", - ], - ordered=False + [self.r, self.r, self.r], ) - self.assertQuerysetEqual( + self.assertSequenceEqual( Reporter.objects.filter(article__reporter__first_name__startswith='John').distinct(), john_smith ) - self.assertQuerysetEqual(Reporter.objects.filter(article__reporter__exact=self.r).distinct(), john_smith) + self.assertSequenceEqual(Reporter.objects.filter(article__reporter__exact=self.r).distinct(), john_smith) # Implied __exact also works. - self.assertQuerysetEqual(Reporter.objects.filter(article__reporter=self.r).distinct(), john_smith) + 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 @@ -370,44 +352,43 @@ class ManyToOneTests(TestCase): ) def test_delete(self): - self.r.article_set.create(headline="John's second story", pub_date=datetime.date(2005, 7, 29)) - self.r2.article_set.create(headline="Paul's story", pub_date=datetime.date(2006, 1, 17)) - Article.objects.create(headline="Third article", pub_date=datetime.date(2005, 7, 27), reporter_id=self.r.id) - Article.objects.create( + 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, his articles will be deleted. - self.assertQuerysetEqual( + self.assertSequenceEqual( Article.objects.all(), - [ - "<Article: Fourth article>", - "<Article: John's second story>", - "<Article: Paul's story>", - "<Article: Third article>", - "<Article: This is a test>", - ] + [new_article4, new_article1, new_article2, new_article3, self.a], ) - self.assertQuerysetEqual( + self.assertSequenceEqual( Reporter.objects.order_by('first_name'), - ["<Reporter: John Smith>", "<Reporter: Paul Jones>"] + [self.r, self.r2], ) self.r2.delete() - self.assertQuerysetEqual( + self.assertSequenceEqual( Article.objects.all(), - [ - "<Article: Fourth article>", - "<Article: John's second story>", - "<Article: Third article>", - "<Article: This is a test>", - ] - ) - self.assertQuerysetEqual(Reporter.objects.order_by('first_name'), ["<Reporter: John Smith>"]) + [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.assertQuerysetEqual(Reporter.objects.all(), []) - self.assertQuerysetEqual(Article.objects.all(), []) + 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 @@ -421,9 +402,9 @@ class ManyToOneTests(TestCase): self.assertEqual(a2.reporter.id, self.r.id) # You can specify filters containing the explicit FK value. - self.assertQuerysetEqual( + self.assertSequenceEqual( Article.objects.filter(reporter_id__exact=self.r.id), - ["<Article: John's second test>", "<Article: This is a test>"] + [a2, self.a], ) # Create an Article by Paul for the same date. @@ -598,15 +579,15 @@ class ManyToOneTests(TestCase): r5 = Record.objects.create(category=c3) Relation.objects.create(left=r1, right=r2) Relation.objects.create(left=r3, right=r4) - Relation.objects.create(left=r1, right=r3) + 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.assertQuerysetEqual(q1, ["<Relation: First - Second>"]) + self.assertSequenceEqual(q1, [rel]) q2 = Category.objects.filter(record__left_set__right__category__name='Second').order_by('name') - self.assertQuerysetEqual(q2, ["<Category: First>", "<Category: Second>"]) + self.assertSequenceEqual(q2, [c1, c2]) p = Parent.objects.create(name="Parent") c = Child.objects.create(name="Child", parent=p) @@ -669,19 +650,19 @@ class ManyToOneTests(TestCase): def test_clear_after_prefetch(self): c = City.objects.create(name='Musical City') - District.objects.create(name='Ladida', city=c) + d = District.objects.create(name='Ladida', city=c) city = City.objects.prefetch_related('districts').get(id=c.id) - self.assertQuerysetEqual(city.districts.all(), ['<District: Ladida>']) + self.assertSequenceEqual(city.districts.all(), [d]) city.districts.clear() - self.assertQuerysetEqual(city.districts.all(), []) + 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.assertQuerysetEqual(city.districts.all(), ['<District: Ladida>']) + self.assertSequenceEqual(city.districts.all(), [d]) city.districts.remove(d) - self.assertQuerysetEqual(city.districts.all(), []) + self.assertSequenceEqual(city.districts.all(), []) def test_add_after_prefetch(self): c = City.objects.create(name='Musical City') @@ -699,7 +680,7 @@ class ManyToOneTests(TestCase): city = City.objects.prefetch_related('districts').get(id=c.id) self.assertEqual(city.districts.count(), 1) city.districts.set([d2]) - self.assertQuerysetEqual(city.districts.all(), ['<District: Ladidu>']) + self.assertSequenceEqual(city.districts.all(), [d2]) def test_add_then_remove_after_prefetch(self): c = City.objects.create(name='Musical City') diff --git a/tests/many_to_one_null/tests.py b/tests/many_to_one_null/tests.py index 401e41b447..d27143bf00 100644 --- a/tests/many_to_one_null/tests.py +++ b/tests/many_to_one_null/tests.py @@ -33,8 +33,8 @@ class ManyToOneNullTests(TestCase): def test_related_set(self): # Reporter objects have access to their related Article objects. - self.assertQuerysetEqual(self.r.article_set.all(), ['<Article: First>', '<Article: Second>']) - self.assertQuerysetEqual(self.r.article_set.filter(headline__startswith='Fir'), ['<Article: First>']) + 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): @@ -47,43 +47,43 @@ class ManyToOneNullTests(TestCase): # if the reporter is set to None. self.assertIsNone(a3.reporter) # To retrieve the articles with no reporters set, use "reporter__isnull=True". - self.assertQuerysetEqual(Article.objects.filter(reporter__isnull=True), ['<Article: Third>']) + 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.assertQuerysetEqual(Article.objects.filter(reporter=None), ['<Article: Third>']) + self.assertSequenceEqual(Article.objects.filter(reporter=None), [self.a3]) # Set the reporter for the Third article - self.assertQuerysetEqual(self.r.article_set.all(), ['<Article: First>', '<Article: Second>']) + self.assertSequenceEqual(self.r.article_set.all(), [self.a, self.a2]) self.r.article_set.add(a3) - self.assertQuerysetEqual( + self.assertSequenceEqual( self.r.article_set.all(), - ['<Article: First>', '<Article: Second>', '<Article: Third>'] + [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.assertQuerysetEqual(self.r.article_set.all(), ['<Article: First>', '<Article: Second>']) - self.assertQuerysetEqual(Article.objects.filter(reporter__isnull=True), ['<Article: Third>']) + 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.assertQuerysetEqual(self.r2.article_set.all(), ['<Article: Fourth>']) + 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.assertQuerysetEqual(self.r2.article_set.all(), ['<Article: Fourth>']) + 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.assertQuerysetEqual(self.r2.article_set.all(), ['<Article: Second>', '<Article: Third>']) + 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.assertQuerysetEqual(self.r2.article_set.all(), ['<Article: Fourth>', '<Article: Third>']) + self.assertSequenceEqual(self.r2.article_set.all(), [self.a4, self.a3]) # Clear the rest of the set self.r2.article_set.set([]) - self.assertQuerysetEqual(self.r2.article_set.all(), []) - self.assertQuerysetEqual( + self.assertSequenceEqual(self.r2.article_set.all(), []) + self.assertSequenceEqual( Article.objects.filter(reporter__isnull=True), - ['<Article: Fourth>', '<Article: Second>', '<Article: Third>'] + [self.a4, self.a2, self.a3], ) def test_set_clear_non_bulk(self): @@ -96,13 +96,13 @@ class ManyToOneNullTests(TestCase): # 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.assertQuerysetEqual(self.r2.article_set.all(), ['<Article: Second>', '<Article: Third>']) + self.assertSequenceEqual(self.r2.article_set.all(), [self.a2, self.a3]) # Clear the rest of the set self.r.article_set.clear() - self.assertQuerysetEqual(self.r.article_set.all(), []) - self.assertQuerysetEqual( + self.assertSequenceEqual(self.r.article_set.all(), []) + self.assertSequenceEqual( Article.objects.filter(reporter__isnull=True), - ['<Article: First>', '<Article: Fourth>'] + [self.a, self.a4], ) def test_assign_with_queryset(self): diff --git a/tests/model_fields/test_datetimefield.py b/tests/model_fields/test_datetimefield.py index ea759e08c6..1c37760711 100644 --- a/tests/model_fields/test_datetimefield.py +++ b/tests/model_fields/test_datetimefield.py @@ -59,14 +59,13 @@ class DateTimeFieldTests(TestCase): 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.assertQuerysetEqual( + self.assertCountEqual( DateTimeModel.objects.filter(dt__date=d), - [repr(m1), repr(m2)], - ordered=False + [m1, m2], ) with self.settings(TIME_ZONE='UTC'): # But in UTC, the __date only matches one of them. - self.assertQuerysetEqual(DateTimeModel.objects.filter(dt__date=d), [repr(m1)]) + self.assertCountEqual(DateTimeModel.objects.filter(dt__date=d), [m1]) class ValidationTest(SimpleTestCase): diff --git a/tests/model_forms/tests.py b/tests/model_forms/tests.py index d7bd768e7b..9931fa50e3 100644 --- a/tests/model_forms/tests.py +++ b/tests/model_forms/tests.py @@ -1444,7 +1444,7 @@ class ModelFormBasicTests(TestCase): article="Hello.", headline="New headline", slug="new-headline", pub_date=datetime.date(1988, 1, 4), writer=self.w_royko) new_art.categories.add(Category.objects.get(name='Entertainment')) - self.assertQuerysetEqual(new_art.categories.all(), ["Entertainment"]) + self.assertSequenceEqual(new_art.categories.all(), [self.c1]) f = ArticleForm(auto_id=False, instance=new_art) self.assertHTMLEqual( f.as_ul(), @@ -1528,7 +1528,7 @@ class ModelFormBasicTests(TestCase): new_art = f.save() new_art = Article.objects.get(id=new_art.id) art_id_1 = new_art.id - self.assertQuerysetEqual(new_art.categories.order_by('name'), ["Entertainment", "It's a test"]) + self.assertSequenceEqual(new_art.categories.order_by('name'), [self.c1, self.c2]) # Now, submit form data with no categories. This deletes the existing categories. form_data['categories'] = [] @@ -1536,7 +1536,7 @@ class ModelFormBasicTests(TestCase): new_art = f.save() self.assertEqual(new_art.id, art_id_1) new_art = Article.objects.get(id=art_id_1) - self.assertQuerysetEqual(new_art.categories.all(), []) + self.assertSequenceEqual(new_art.categories.all(), []) # Create a new article, with no categories, via the form. f = ArticleForm(form_data) @@ -1544,7 +1544,7 @@ class ModelFormBasicTests(TestCase): art_id_2 = new_art.id self.assertNotIn(art_id_2, (None, art_id_1)) new_art = Article.objects.get(id=art_id_2) - self.assertQuerysetEqual(new_art.categories.all(), []) + self.assertSequenceEqual(new_art.categories.all(), []) # Create a new article, with categories, via the form, but use commit=False. # The m2m data won't be saved until save_m2m() is invoked on the form. @@ -1559,11 +1559,11 @@ class ModelFormBasicTests(TestCase): # The instance doesn't have m2m data yet new_art = Article.objects.get(id=art_id_3) - self.assertQuerysetEqual(new_art.categories.all(), []) + self.assertSequenceEqual(new_art.categories.all(), []) # Save the m2m data on the form f.save_m2m() - self.assertQuerysetEqual(new_art.categories.order_by('name'), ["Entertainment", "It's a test"]) + self.assertSequenceEqual(new_art.categories.order_by('name'), [self.c1, self.c2]) def test_custom_form_fields(self): # Here, we define a custom ModelForm. Because it happens to have the same fields as @@ -1720,20 +1720,20 @@ class ModelMultipleChoiceFieldTests(TestCase): f.clean(None) with self.assertRaises(ValidationError): f.clean([]) - self.assertQuerysetEqual(f.clean([self.c1.id]), ["Entertainment"]) - self.assertQuerysetEqual(f.clean([self.c2.id]), ["It's a test"]) - self.assertQuerysetEqual(f.clean([str(self.c1.id)]), ["Entertainment"]) - self.assertQuerysetEqual( + self.assertCountEqual(f.clean([self.c1.id]), [self.c1]) + self.assertCountEqual(f.clean([self.c2.id]), [self.c2]) + self.assertCountEqual(f.clean([str(self.c1.id)]), [self.c1]) + self.assertCountEqual( f.clean([str(self.c1.id), str(self.c2.id)]), - ["Entertainment", "It's a test"], ordered=False + [self.c1, self.c2], ) - self.assertQuerysetEqual( + self.assertCountEqual( f.clean([self.c1.id, str(self.c2.id)]), - ["Entertainment", "It's a test"], ordered=False + [self.c1, self.c2], ) - self.assertQuerysetEqual( + self.assertCountEqual( f.clean((self.c1.id, str(self.c2.id))), - ["Entertainment", "It's a test"], ordered=False + [self.c1, self.c2], ) with self.assertRaises(ValidationError): f.clean(['100']) @@ -1755,7 +1755,7 @@ class ModelMultipleChoiceFieldTests(TestCase): # this may create categories with primary keys up to 6. Use # a number that will not conflict. c6 = Category.objects.create(id=1006, name='Sixth', url='6th') - self.assertQuerysetEqual(f.clean([c6.id]), ["Sixth"]) + self.assertCountEqual(f.clean([c6.id]), [c6]) # Delete a Category object *after* the ModelMultipleChoiceField has already been # instantiated. This proves clean() checks the database during clean() rather @@ -1780,7 +1780,7 @@ class ModelMultipleChoiceFieldTests(TestCase): self.assertEqual(list(f.choices), [ (self.c1.pk, 'Entertainment'), (self.c2.pk, "It's a test")]) - self.assertQuerysetEqual(f.clean([self.c2.id]), ["It's a test"]) + self.assertSequenceEqual(f.clean([self.c2.id]), [self.c2]) with self.assertRaises(ValidationError): f.clean([self.c3.id]) with self.assertRaises(ValidationError): @@ -2512,7 +2512,7 @@ class OtherModelFormTests(TestCase): def test_foreignkeys_which_use_to_field(self): apple = Inventory.objects.create(barcode=86, name='Apple') - Inventory.objects.create(barcode=22, name='Pear') + pear = Inventory.objects.create(barcode=22, name='Pear') core = Inventory.objects.create(barcode=87, name='Core', parent=apple) field = forms.ModelChoiceField(Inventory.objects.all(), to_field_name='barcode') @@ -2555,12 +2555,12 @@ class OtherModelFormTests(TestCase): field = forms.ModelMultipleChoiceField(Inventory.objects.all(), to_field_name='barcode') self.assertEqual(tuple(field.choices), ((86, 'Apple'), (87, 'Core'), (22, 'Pear'))) - self.assertQuerysetEqual(field.clean([86]), ['Apple']) + self.assertSequenceEqual(field.clean([86]), [apple]) form = SelectInventoryForm({'items': [87, 22]}) self.assertTrue(form.is_valid()) self.assertEqual(len(form.cleaned_data), 1) - self.assertQuerysetEqual(form.cleaned_data['items'], ['Core', 'Pear']) + self.assertSequenceEqual(form.cleaned_data['items'], [core, pear]) def test_model_field_that_returns_none_to_exclude_itself_with_explicit_fields(self): self.assertEqual(list(CustomFieldForExclusionForm.base_fields), ['name']) diff --git a/tests/model_formsets/tests.py b/tests/model_formsets/tests.py index 9c06d45339..98fd501ad6 100644 --- a/tests/model_formsets/tests.py +++ b/tests/model_formsets/tests.py @@ -368,21 +368,19 @@ class ModelFormsetTest(TestCase): instance.created = date.today() instance.save() formset.save_m2m() - self.assertQuerysetEqual(instances[0].authors.all(), [ - '<Author: Charles Baudelaire>', - '<Author: John Steinbeck>', - '<Author: Paul Verlaine>', - '<Author: Walt Whitman>', - ]) + self.assertSequenceEqual( + instances[0].authors.all(), + [author1, author4, author2, author3], + ) def test_max_num(self): # Test the behavior of max_num with model formsets. It should allow # all existing related objects/inlines for a given object to be # displayed, but not allow the creation of new inlines beyond max_num. - Author.objects.create(name='Charles Baudelaire') - Author.objects.create(name='Paul Verlaine') - Author.objects.create(name='Walt Whitman') + a1 = Author.objects.create(name='Charles Baudelaire') + a2 = Author.objects.create(name='Paul Verlaine') + a3 = Author.objects.create(name='Walt Whitman') qs = Author.objects.order_by('name') @@ -403,27 +401,15 @@ class ModelFormsetTest(TestCase): AuthorFormSet = modelformset_factory(Author, fields="__all__", max_num=None) formset = AuthorFormSet(queryset=qs) - self.assertQuerysetEqual(formset.get_queryset(), [ - '<Author: Charles Baudelaire>', - '<Author: Paul Verlaine>', - '<Author: Walt Whitman>', - ]) + self.assertSequenceEqual(formset.get_queryset(), [a1, a2, a3]) AuthorFormSet = modelformset_factory(Author, fields="__all__", max_num=0) formset = AuthorFormSet(queryset=qs) - self.assertQuerysetEqual(formset.get_queryset(), [ - '<Author: Charles Baudelaire>', - '<Author: Paul Verlaine>', - '<Author: Walt Whitman>', - ]) + self.assertSequenceEqual(formset.get_queryset(), [a1, a2, a3]) AuthorFormSet = modelformset_factory(Author, fields="__all__", max_num=4) formset = AuthorFormSet(queryset=qs) - self.assertQuerysetEqual(formset.get_queryset(), [ - '<Author: Charles Baudelaire>', - '<Author: Paul Verlaine>', - '<Author: Walt Whitman>', - ]) + self.assertSequenceEqual(formset.get_queryset(), [a1, a2, a3]) def test_min_num(self): # Test the behavior of min_num with model formsets. It should be @@ -633,7 +619,7 @@ class ModelFormsetTest(TestCase): self.assertEqual(len(saved), 1) book1, = saved self.assertEqual(book1, Book.objects.get(title='Les Fleurs du Mal')) - self.assertQuerysetEqual(author.book_set.all(), ['<Book: Les Fleurs du Mal>']) + self.assertSequenceEqual(author.book_set.all(), [book1]) # Now that we've added a book to Charles Baudelaire, let's try adding # another one. This time though, an edit form will be available for @@ -689,10 +675,7 @@ class ModelFormsetTest(TestCase): # As you can see, 'Les Paradis Artificiels' is now a book belonging to # Charles Baudelaire. - self.assertQuerysetEqual(author.book_set.order_by('title'), [ - '<Book: Les Fleurs du Mal>', - '<Book: Les Paradis Artificiels>', - ]) + self.assertSequenceEqual(author.book_set.order_by('title'), [book1, book2]) def test_inline_formsets_save_as_new(self): # The save_as_new parameter lets you re-associate the data to a new @@ -1722,7 +1705,7 @@ class ModelFormsetTest(TestCase): formset.save() # The name of other_author shouldn't be changed and new models aren't # created. - self.assertQuerysetEqual(Author.objects.all(), ['<Author: Charles>', '<Author: Walt>']) + self.assertSequenceEqual(Author.objects.all(), [author, other_author]) def test_validation_without_id(self): AuthorFormSet = modelformset_factory(Author, fields='__all__') diff --git a/tests/model_formsets_regress/tests.py b/tests/model_formsets_regress/tests.py index 9f7bbff05e..8e480b7266 100644 --- a/tests/model_formsets_regress/tests.py +++ b/tests/model_formsets_regress/tests.py @@ -246,7 +246,10 @@ class InlineFormsetTests(TestCase): formset.save() self.assertQuerysetEqual( dalnet.host_set.order_by("hostname"), - ["<Host: matrix.de.eu.dal.net>", "<Host: tranquility.hub.dal.net>"] + Host.objects.filter(hostname__in=[ + 'matrix.de.eu.dal.net', + 'tranquility.hub.dal.net', + ]).order_by('hostname'), ) def test_initial_data(self): diff --git a/tests/one_to_one/tests.py b/tests/one_to_one/tests.py index bb3e5aebbf..6100e53208 100644 --- a/tests/one_to_one/tests.py +++ b/tests/one_to_one/tests.py @@ -46,15 +46,10 @@ class OneToOneTests(TestCase): def test_manager_all(self): # Restaurant.objects.all() just returns the Restaurants, not the Places. - self.assertQuerysetEqual(Restaurant.objects.all(), [ - '<Restaurant: Demon Dogs the restaurant>', - ]) + self.assertSequenceEqual(Restaurant.objects.all(), [self.r1]) # Place.objects.all() returns all Places, regardless of whether they # have Restaurants. - self.assertQuerysetEqual(Place.objects.order_by('name'), [ - '<Place: Ace Hardware the place>', - '<Place: Demon Dogs the place>', - ]) + self.assertSequenceEqual(Place.objects.order_by('name'), [self.p2, self.p1]) def test_manager_get(self): def assert_get_restaurant(**params): @@ -92,9 +87,7 @@ class OneToOneTests(TestCase): # Query the waiters def assert_filter_waiters(**params): - self.assertQuerysetEqual(Waiter.objects.filter(**params), [ - '<Waiter: Joe the waiter at Demon Dogs the restaurant>' - ]) + 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) @@ -169,10 +162,7 @@ class OneToOneTests(TestCase): f = Favorites(name='Fred') f.save() f.restaurants.set([self.r1]) - self.assertQuerysetEqual( - f.restaurants.all(), - ['<Restaurant: Demon Dogs the restaurant>'] - ) + self.assertSequenceEqual(f.restaurants.all(), [self.r1]) def test_reverse_object_cache(self): """ diff --git a/tests/pagination/tests.py b/tests/pagination/tests.py index d781bdf8a7..43e8c28046 100644 --- a/tests/pagination/tests.py +++ b/tests/pagination/tests.py @@ -433,21 +433,17 @@ class ModelPaginationTests(TestCase): @classmethod def setUpTestData(cls): # Prepare a list of objects for pagination. - for x in range(1, 10): - a = Article(headline='Article %s' % x, pub_date=datetime(2005, 7, 29)) - a.save() + 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("<Page 1 of 2>", str(p)) - self.assertQuerysetEqual(p.object_list, [ - "<Article: Article 1>", - "<Article: Article 2>", - "<Article: Article 3>", - "<Article: Article 4>", - "<Article: Article 5>" - ]) + self.assertSequenceEqual(p.object_list, self.articles[:5]) self.assertTrue(p.has_next()) self.assertFalse(p.has_previous()) self.assertTrue(p.has_other_pages()) @@ -461,12 +457,7 @@ class ModelPaginationTests(TestCase): paginator = Paginator(Article.objects.order_by('id'), 5) p = paginator.page(2) self.assertEqual("<Page 2 of 2>", str(p)) - self.assertQuerysetEqual(p.object_list, [ - "<Article: Article 6>", - "<Article: Article 7>", - "<Article: Article 8>", - "<Article: Article 9>" - ]) + self.assertSequenceEqual(p.object_list, self.articles[5:]) self.assertFalse(p.has_next()) self.assertTrue(p.has_previous()) self.assertTrue(p.has_other_pages()) @@ -494,12 +485,8 @@ class ModelPaginationTests(TestCase): self.assertNotIsInstance(p.object_list, list) # Make sure slicing the Page object with numbers and slice objects work. - self.assertEqual(p[0], Article.objects.get(headline='Article 1')) - self.assertQuerysetEqual(p[slice(2)], [ - "<Article: Article 1>", - "<Article: Article 2>", - ] - ) + 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) diff --git a/tests/prefetch_related/tests.py b/tests/prefetch_related/tests.py index c368e040ea..e21bd5ec23 100644 --- a/tests/prefetch_related/tests.py +++ b/tests/prefetch_related/tests.py @@ -76,7 +76,7 @@ class PrefetchRelatedTests(TestDataMixin, TestCase): [list(b.first_time_authors.all()) for b in Book.objects.prefetch_related('first_time_authors')] - self.assertQuerysetEqual(self.book2.authors.all(), ["<Author: Charlotte>"]) + self.assertSequenceEqual(self.book2.authors.all(), [self.author1]) def test_onetoone_reverse_no_match(self): # Regression for #17439 @@ -1580,4 +1580,4 @@ class ReadPrefetchedObjectsCacheTests(TestCase): ) with self.assertNumQueries(4): # AuthorWithAge -> Author -> FavoriteAuthors, Book - self.assertQuerysetEqual(authors, ['<AuthorWithAge: Rousseau>', '<AuthorWithAge: Voltaire>']) + self.assertSequenceEqual(authors, [self.author1, self.author2]) diff --git a/tests/queries/tests.py b/tests/queries/tests.py index c3e3a40340..37ba239419 100644 --- a/tests/queries/tests.py +++ b/tests/queries/tests.py @@ -38,20 +38,20 @@ from .models import ( class Queries1Tests(TestCase): @classmethod def setUpTestData(cls): - generic = NamedCategory.objects.create(name="Generic") + 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) - t4 = Tag.objects.create(name='t4', parent=cls.t3) + 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) - ann1 = Annotation.objects.create(name='a1', tag=cls.t1) - ann1.notes.add(cls.n1) - ann2 = Annotation.objects.create(name='a2', tag=t4) + 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 @@ -73,19 +73,19 @@ class Queries1Tests(TestCase): 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) - i4 = Item.objects.create(name='four', created=time4, creator=cls.a4, note=cls.n3) - i4.tags.set([t4]) + 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) - Report.objects.create(name='r2', creator=cls.a3) - Report.objects.create(name='r3') + 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) - Cover.objects.create(title="first", item=i4) - Cover.objects.create(title="second", item=cls.i2) + 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) @@ -101,27 +101,27 @@ class Queries1Tests(TestCase): self.assertEqual(str(qs4.query).lower().count('u0.'), 4) def test_ticket1050(self): - self.assertQuerysetEqual( + self.assertSequenceEqual( Item.objects.filter(tags__isnull=True), - ['<Item: three>'] + [self.i3], ) - self.assertQuerysetEqual( + self.assertSequenceEqual( Item.objects.filter(tags__id__isnull=True), - ['<Item: three>'] + [self.i3], ) def test_ticket1801(self): - self.assertQuerysetEqual( + self.assertSequenceEqual( Author.objects.filter(item=self.i2), - ['<Author: a2>'] + [self.a2], ) - self.assertQuerysetEqual( + self.assertSequenceEqual( Author.objects.filter(item=self.i3), - ['<Author: a2>'] + [self.a2], ) - self.assertQuerysetEqual( + self.assertSequenceEqual( Author.objects.filter(item=self.i2) & Author.objects.filter(item=self.i3), - ['<Author: a2>'] + [self.a2], ) def test_ticket2306(self): @@ -129,84 +129,84 @@ class Queries1Tests(TestCase): query = Item.objects.filter(tags=self.t2).query self.assertNotIn(LOUTER, [x.join_type for x in query.alias_map.values()]) - self.assertQuerysetEqual( + self.assertSequenceEqual( Item.objects.filter(Q(tags=self.t1)).order_by('name'), - ['<Item: one>', '<Item: two>'] + [self.i1, self.i2], ) - self.assertQuerysetEqual( + self.assertSequenceEqual( Item.objects.filter(Q(tags=self.t1)).filter(Q(tags=self.t2)), - ['<Item: one>'] + [self.i1], ) - self.assertQuerysetEqual( + self.assertSequenceEqual( Item.objects.filter(Q(tags=self.t1)).filter(Q(creator__name='fred') | Q(tags=self.t2)), - ['<Item: one>'] + [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.assertQuerysetEqual( + self.assertSequenceEqual( Item.objects.filter(Q(tags=self.t1) & Q(tags=self.t2)), [] ) - self.assertQuerysetEqual( + 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.assertQuerysetEqual(list(qs), ['<Author: a2>']) + 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.assertQuerysetEqual( + self.assertSequenceEqual( Item.objects.filter(tags=self.t1).filter(tags=self.t2), - ['<Item: one>'] + [self.i1], ) - self.assertQuerysetEqual( + self.assertSequenceEqual( Item.objects.filter(tags__in=[self.t1, self.t2]).distinct().order_by('name'), - ['<Item: one>', '<Item: two>'] + [self.i1, self.i2], ) - self.assertQuerysetEqual( + self.assertSequenceEqual( Item.objects.filter(tags__in=[self.t1, self.t2]).filter(tags=self.t3), - ['<Item: two>'] + [self.i2], ) # Make sure .distinct() works with slicing (this was broken in Oracle). - self.assertQuerysetEqual( + self.assertSequenceEqual( Item.objects.filter(tags__in=[self.t1, self.t2]).order_by('name')[:3], - ['<Item: one>', '<Item: one>', '<Item: two>'] + [self.i1, self.i1, self.i2], ) - self.assertQuerysetEqual( + self.assertSequenceEqual( Item.objects.filter(tags__in=[self.t1, self.t2]).distinct().order_by('name')[:3], - ['<Item: one>', '<Item: two>'] + [self.i1, self.i2], ) def test_tickets_2080_3592(self): - self.assertQuerysetEqual( + self.assertSequenceEqual( Author.objects.filter(item__name='one') | Author.objects.filter(name='a3'), - ['<Author: a1>', '<Author: a3>'] + [self.a1, self.a3], ) - self.assertQuerysetEqual( + self.assertSequenceEqual( Author.objects.filter(Q(item__name='one') | Q(name='a3')), - ['<Author: a1>', '<Author: a3>'] + [self.a1, self.a3], ) - self.assertQuerysetEqual( + self.assertSequenceEqual( Author.objects.filter(Q(name='a3') | Q(item__name='one')), - ['<Author: a1>', '<Author: a3>'] + [self.a1, self.a3], ) - self.assertQuerysetEqual( + self.assertSequenceEqual( Author.objects.filter(Q(item__name='three') | Q(report__name='r3')), - ['<Author: a2>'] + [self.a2], ) def test_ticket6074(self): # Merging two empty result sets shouldn't leave a queryset with no constraints # (which would match everything). - self.assertQuerysetEqual(Author.objects.filter(Q(id__in=[])), []) - self.assertQuerysetEqual( + self.assertSequenceEqual(Author.objects.filter(Q(id__in=[])), []) + self.assertSequenceEqual( Author.objects.filter(Q(id__in=[]) | Q(id__in=[])), [] ) @@ -252,23 +252,20 @@ class Queries1Tests(TestCase): def test_ticket2253(self): q1 = Item.objects.order_by('name') q2 = Item.objects.filter(id=self.i1.id) - self.assertQuerysetEqual( - q1, - ['<Item: four>', '<Item: one>', '<Item: three>', '<Item: two>'] - ) - self.assertQuerysetEqual(q2, ['<Item: one>']) - self.assertQuerysetEqual( + self.assertSequenceEqual(q1, [self.i4, self.i1, self.i3, self.i2]) + self.assertSequenceEqual(q2, [self.i1]) + self.assertSequenceEqual( (q1 | q2).order_by('name'), - ['<Item: four>', '<Item: one>', '<Item: three>', '<Item: two>'] + [self.i4, self.i1, self.i3, self.i2], ) - self.assertQuerysetEqual((q1 & q2).order_by('name'), ['<Item: one>']) + 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.assertQuerysetEqual( + self.assertSequenceEqual( ((q1 & q2) | q3).order_by('name'), - ['<Item: four>', '<Item: one>'] + [self.i4, self.i1], ) def test_order_by_tables(self): @@ -299,60 +296,57 @@ class Queries1Tests(TestCase): self.assertNotIn('order by', captured_queries[0]['sql'].lower()) def test_tickets_4088_4306(self): - self.assertQuerysetEqual( - Report.objects.filter(creator=1001), - ['<Report: r1>'] - ) - self.assertQuerysetEqual( + self.assertSequenceEqual(Report.objects.filter(creator=1001), [self.r1]) + self.assertSequenceEqual( Report.objects.filter(creator__num=1001), - ['<Report: r1>'] + [self.r1] ) - self.assertQuerysetEqual(Report.objects.filter(creator__id=1001), []) - self.assertQuerysetEqual( + self.assertSequenceEqual(Report.objects.filter(creator__id=1001), []) + self.assertSequenceEqual( Report.objects.filter(creator__id=self.a1.id), - ['<Report: r1>'] + [self.r1] ) - self.assertQuerysetEqual( + self.assertSequenceEqual( Report.objects.filter(creator__name='a1'), - ['<Report: r1>'] + [self.r1] ) def test_ticket4510(self): - self.assertQuerysetEqual( + self.assertSequenceEqual( Author.objects.filter(report__name='r1'), - ['<Author: a1>'] + [self.a1], ) def test_ticket7378(self): - self.assertQuerysetEqual(self.a1.report_set.all(), ['<Report: r1>']) + self.assertSequenceEqual(self.a1.report_set.all(), [self.r1]) def test_tickets_5324_6704(self): - self.assertQuerysetEqual( + self.assertSequenceEqual( Item.objects.filter(tags__name='t4'), - ['<Item: four>'] + [self.i4], ) - self.assertQuerysetEqual( + self.assertSequenceEqual( Item.objects.exclude(tags__name='t4').order_by('name').distinct(), - ['<Item: one>', '<Item: three>', '<Item: two>'] + [self.i1, self.i3, self.i2], ) - self.assertQuerysetEqual( + self.assertSequenceEqual( Item.objects.exclude(tags__name='t4').order_by('name').distinct().reverse(), - ['<Item: two>', '<Item: three>', '<Item: one>'] + [self.i2, self.i3, self.i1], ) - self.assertQuerysetEqual( + self.assertSequenceEqual( Author.objects.exclude(item__name='one').distinct().order_by('name'), - ['<Author: a2>', '<Author: a3>', '<Author: a4>'] + [self.a2, self.a3, self.a4], ) # Excluding across a m2m relation when there is more than one related # object associated was problematic. - self.assertQuerysetEqual( + self.assertSequenceEqual( Item.objects.exclude(tags__name='t1').order_by('name'), - ['<Item: four>', '<Item: three>'] + [self.i4, self.i3], ) - self.assertQuerysetEqual( + self.assertSequenceEqual( Item.objects.exclude(tags__name='t1').exclude(tags__name='t4'), - ['<Item: three>'] + [self.i3], ) # Excluding from a relation that cannot be NULL should not use outer joins. @@ -373,37 +367,34 @@ class Queries1Tests(TestCase): ) # The previous changes shouldn't affect nullable foreign key joins. - self.assertQuerysetEqual( + self.assertSequenceEqual( Tag.objects.filter(parent__isnull=True).order_by('name'), - ['<Tag: t1>'] + [self.t1] ) - self.assertQuerysetEqual( + self.assertSequenceEqual( Tag.objects.exclude(parent__isnull=True).order_by('name'), - ['<Tag: t2>', '<Tag: t3>', '<Tag: t4>', '<Tag: t5>'] + [self.t2, self.t3, self.t4, self.t5], ) - self.assertQuerysetEqual( + self.assertSequenceEqual( Tag.objects.exclude(Q(parent__name='t1') | Q(parent__isnull=True)).order_by('name'), - ['<Tag: t4>', '<Tag: t5>'] + [self.t4, self.t5], ) - self.assertQuerysetEqual( + self.assertSequenceEqual( Tag.objects.exclude(Q(parent__isnull=True) | Q(parent__name='t1')).order_by('name'), - ['<Tag: t4>', '<Tag: t5>'] + [self.t4, self.t5], ) - self.assertQuerysetEqual( + self.assertSequenceEqual( Tag.objects.exclude(Q(parent__parent__isnull=True)).order_by('name'), - ['<Tag: t4>', '<Tag: t5>'] + [self.t4, self.t5], ) - self.assertQuerysetEqual( + self.assertSequenceEqual( Tag.objects.filter(~Q(parent__parent__isnull=True)).order_by('name'), - ['<Tag: t4>', '<Tag: t5>'] + [self.t4, self.t5], ) def test_ticket2091(self): t = Tag.objects.get(name='t4') - self.assertQuerysetEqual( - Item.objects.filter(tags__in=[t]), - ['<Item: four>'] - ) + 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) @@ -440,19 +431,19 @@ class Queries1Tests(TestCase): ) def test_ticket2400(self): - self.assertQuerysetEqual( + self.assertSequenceEqual( Author.objects.filter(item__isnull=True), - ['<Author: a3>'] + [self.a3], ) - self.assertQuerysetEqual( + self.assertSequenceEqual( Tag.objects.filter(item__isnull=True), - ['<Tag: t5>'] + [self.t5], ) def test_ticket2496(self): - self.assertQuerysetEqual( + self.assertSequenceEqual( Item.objects.extra(tables=['queries_author']).select_related().order_by('name')[:1], - ['<Item: four>'] + [self.i4], ) def test_error_raised_on_filter_with_dictionary(self): @@ -462,56 +453,47 @@ class Queries1Tests(TestCase): def test_tickets_2076_7256(self): # Ordering on related tables should be possible, even if the table is # not otherwise involved. - self.assertQuerysetEqual( + self.assertSequenceEqual( Item.objects.order_by('note__note', 'name'), - ['<Item: two>', '<Item: four>', '<Item: one>', '<Item: three>'] + [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.assertQuerysetEqual( + self.assertSequenceEqual( Author.objects.order_by('extra', '-name'), - ['<Author: a2>', '<Author: a1>', '<Author: a4>', '<Author: a3>'] + [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.assertQuerysetEqual( - Cover.objects.all(), - ['<Cover: first>', '<Cover: second>'] - ) + 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.assertQuerysetEqual( + self.assertSequenceEqual( Item.objects.order_by('creator', 'name'), - ['<Item: one>', '<Item: three>', '<Item: two>', '<Item: four>'] + [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.assertQuerysetEqual( + self.assertSequenceEqual( Item.objects.filter(tags__isnull=False).order_by('tags', 'id'), - ['<Item: one>', '<Item: two>', '<Item: one>', '<Item: two>', '<Item: four>'] + [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.assertQuerysetEqual( - qs, - ['<Item: four>', '<Item: one>', '<Item: three>', '<Item: two>'] - ) + 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, - ['<Item: two>', '<Item: four>', '<Item: one>', '<Item: three>'] - ) + 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. @@ -519,9 +501,9 @@ class Queries1Tests(TestCase): self.assertEqual(repr(qs[0].creator.extra.note), '<Note: n1>') def test_ticket3037(self): - self.assertQuerysetEqual( + self.assertSequenceEqual( Item.objects.filter(Q(creator__name='a3', name='two') | Q(creator__name='a4', name='four')), - ['<Item: four>'] + [self.i4], ) def test_tickets_5321_7070(self): @@ -550,29 +532,29 @@ class Queries1Tests(TestCase): def test_ticket6154(self): # Multiple filter statements are joined using "AND" all the time. - self.assertQuerysetEqual( + self.assertSequenceEqual( Author.objects.filter(id=self.a1.id).filter(Q(extra__note=self.n1) | Q(item__note=self.n3)), - ['<Author: a1>'] + [self.a1], ) - self.assertQuerysetEqual( + self.assertSequenceEqual( Author.objects.filter(Q(extra__note=self.n1) | Q(item__note=self.n3)).filter(id=self.a1.id), - ['<Author: a1>'] + [self.a1], ) def test_ticket6981(self): - self.assertQuerysetEqual( + self.assertSequenceEqual( Tag.objects.select_related('parent').order_by('name'), - ['<Tag: t1>', '<Tag: t2>', '<Tag: t3>', '<Tag: t4>', '<Tag: t5>'] + [self.t1, self.t2, self.t3, self.t4, self.t5], ) def test_ticket9926(self): - self.assertQuerysetEqual( + self.assertSequenceEqual( Tag.objects.select_related("parent", "category").order_by('name'), - ['<Tag: t1>', '<Tag: t2>', '<Tag: t3>', '<Tag: t4>', '<Tag: t5>'] + [self.t1, self.t2, self.t3, self.t4, self.t5], ) - self.assertQuerysetEqual( + self.assertSequenceEqual( Tag.objects.select_related('parent', "parent__category").order_by('name'), - ['<Tag: t1>', '<Tag: t2>', '<Tag: t3>', '<Tag: t4>', '<Tag: t5>'] + [self.t1, self.t2, self.t3, self.t4, self.t5], ) def test_tickets_6180_6203(self): @@ -585,31 +567,31 @@ class Queries1Tests(TestCase): def test_tickets_7087_12242(self): # Dates with extra select columns - self.assertQuerysetEqual( + 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)'] + [datetime.datetime(2007, 12, 19, 0, 0), datetime.datetime(2007, 12, 20, 0, 0)], ) - self.assertQuerysetEqual( + 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)'] + [datetime.datetime(2007, 12, 19, 0, 0), datetime.datetime(2007, 12, 20, 0, 0)], ) name = "one" - self.assertQuerysetEqual( + self.assertSequenceEqual( Item.objects.datetimes('created', 'day').extra(where=['name=%s'], params=[name]), - ['datetime.datetime(2007, 12, 19, 0, 0)'] + [datetime.datetime(2007, 12, 19, 0, 0)], ) - self.assertQuerysetEqual( + self.assertSequenceEqual( Item.objects.extra(where=['name=%s'], params=[name]).datetimes('created', 'day'), - ['datetime.datetime(2007, 12, 19, 0, 0)'] + [datetime.datetime(2007, 12, 19, 0, 0)], ) def test_ticket7155(self): # Nullable dates - self.assertQuerysetEqual( + self.assertSequenceEqual( Item.objects.datetimes('modified', 'day'), - ['datetime.datetime(2007, 12, 19, 0, 0)'] + [datetime.datetime(2007, 12, 19, 0, 0)], ) @ignore_warnings(category=RemovedInDjango40Warning) @@ -644,35 +626,35 @@ class Queries1Tests(TestCase): def test_ticket7096(self): # Make sure exclude() with multiple conditions continues to work. - self.assertQuerysetEqual( + self.assertSequenceEqual( Tag.objects.filter(parent=self.t1, name='t3').order_by('name'), - ['<Tag: t3>'] + [self.t3], ) - self.assertQuerysetEqual( + self.assertSequenceEqual( Tag.objects.exclude(parent=self.t1, name='t3').order_by('name'), - ['<Tag: t1>', '<Tag: t2>', '<Tag: t4>', '<Tag: t5>'] + [self.t1, self.t2, self.t4, self.t5], ) - self.assertQuerysetEqual( + self.assertSequenceEqual( Item.objects.exclude(tags__name='t1', name='one').order_by('name').distinct(), - ['<Item: four>', '<Item: three>', '<Item: two>'] + [self.i4, self.i3, self.i2], ) - self.assertQuerysetEqual( + self.assertSequenceEqual( Item.objects.filter(name__in=['three', 'four']).exclude(tags__name='t1').order_by('name'), - ['<Item: four>', '<Item: three>'] + [self.i4, self.i3], ) # More twisted cases, involving nested negations. - self.assertQuerysetEqual( + self.assertSequenceEqual( Item.objects.exclude(~Q(tags__name='t1', name='one')), - ['<Item: one>'] + [self.i1], ) - self.assertQuerysetEqual( + self.assertSequenceEqual( Item.objects.filter(~Q(tags__name='t1', name='one'), name='two'), - ['<Item: two>'] + [self.i2], ) - self.assertQuerysetEqual( + self.assertSequenceEqual( Item.objects.exclude(~Q(tags__name='t1', name='one'), name='two'), - ['<Item: four>', '<Item: one>', '<Item: three>'] + [self.i4, self.i1, self.i3], ) def test_tickets_7204_7506(self): @@ -701,19 +683,19 @@ class Queries1Tests(TestCase): self.assertEqual(list(qs), list(q3)) def test_ticket7277(self): - self.assertQuerysetEqual( + self.assertSequenceEqual( self.n1.annotation_set.filter( Q(tag=self.t5) | Q(tag__children=self.t5) | Q(tag__children__children=self.t5) ), - ['<Annotation: a1>'] + [self.ann1], ) def test_tickets_7448_7707(self): # Complex objects should be converted to strings before being used in # lookups. - self.assertQuerysetEqual( + self.assertSequenceEqual( Item.objects.filter(created__in=[self.time1, self.time2]), - ['<Item: one>', '<Item: two>'] + [self.i1, self.i2], ) def test_ticket7235(self): @@ -756,9 +738,9 @@ class Queries1Tests(TestCase): # 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.assertQuerysetEqual( + self.assertSequenceEqual( Tag.objects.filter(name__in=Tag.objects.filter(parent=self.t1).values('name')), - ['<Tag: t2>', '<Tag: t3>'] + [self.t2, self.t3], ) # Multi-valued values() and values_list() querysets should raise errors. @@ -773,9 +755,9 @@ class Queries1Tests(TestCase): Note.objects.values_list("note", flat=True).values("id").order_by("id"), [{'id': 1}, {'id': 2}, {'id': 3}] ) - self.assertQuerysetEqual( + self.assertSequenceEqual( Annotation.objects.filter(notes__in=Note.objects.filter(note="n1").values_list('note').values('id')), - ['<Annotation: a1>'] + [self.ann1], ) def test_ticket10205(self): @@ -799,22 +781,22 @@ class Queries1Tests(TestCase): subq = Author.objects.filter(num__lt=3000) qs = Author.objects.filter(pk__in=subq) - self.assertQuerysetEqual(qs, ['<Author: a1>', '<Author: a2>']) + 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.assertQuerysetEqual(qs, ['<Author: a3>', '<Author: a4>']) + 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.assertQuerysetEqual( + self.assertSequenceEqual( Author.objects.filter(Q(pk__in=subq) & Q(name='a1')), - ['<Author: a1>'] + [self.a1], ) # The subquery result cache should not be populated @@ -822,13 +804,13 @@ class Queries1Tests(TestCase): def test_ticket7076(self): # Excluding shouldn't eliminate NULL entries. - self.assertQuerysetEqual( + self.assertSequenceEqual( Item.objects.exclude(modified=self.time1).order_by('name'), - ['<Item: four>', '<Item: three>', '<Item: two>'] + [self.i4, self.i3, self.i2], ) - self.assertQuerysetEqual( + self.assertSequenceEqual( Tag.objects.exclude(parent__name=self.t1.name), - ['<Tag: t1>', '<Tag: t4>', '<Tag: t5>'] + [self.t1, self.t4, self.t5], ) def test_ticket7181(self): @@ -838,36 +820,36 @@ class Queries1Tests(TestCase): self.assertEqual(len(Tag.objects.order_by('parent__name')), 5) # Empty querysets can be merged with others. - self.assertQuerysetEqual( + self.assertSequenceEqual( Note.objects.none() | Note.objects.all(), - ['<Note: n1>', '<Note: n2>', '<Note: n3>'] + [self.n1, self.n2, self.n3], ) - self.assertQuerysetEqual( + self.assertSequenceEqual( Note.objects.all() | Note.objects.none(), - ['<Note: n1>', '<Note: n2>', '<Note: n3>'] + [self.n1, self.n2, self.n3], ) - self.assertQuerysetEqual(Note.objects.none() & Note.objects.all(), []) - self.assertQuerysetEqual(Note.objects.all() & Note.objects.none(), []) + 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.assertQuerysetEqual( + self.assertSequenceEqual( Author.objects.filter(Q(item__note__extrainfo=self.e2) | Q(report=self.r1, name='xyz')), - ['<Author: a2>'] + [self.a2], ) - self.assertQuerysetEqual( + self.assertSequenceEqual( Author.objects.filter(Q(report=self.r1, name='xyz') | Q(item__note__extrainfo=self.e2)), - ['<Author: a2>'] + [self.a2], ) - self.assertQuerysetEqual( + self.assertSequenceEqual( Annotation.objects.filter(Q(tag__parent=self.t1) | Q(notes__note='n1', name='a1')), - ['<Annotation: a1>'] + [self.ann1], ) xx = ExtraInfo.objects.create(info='xx', note=self.n3) - self.assertQuerysetEqual( + self.assertSequenceEqual( Note.objects.filter(Q(extrainfo__author=self.a1) | Q(extrainfo=xx)), - ['<Note: n1>', '<Note: n3>'] + [self.n1, self.n3], ) q = Note.objects.filter(Q(extrainfo__author=self.a1) | Q(extrainfo=xx)).query self.assertEqual( @@ -882,10 +864,9 @@ class Queries1Tests(TestCase): original_ordering = Tag._meta.ordering Tag._meta.ordering = None try: - self.assertQuerysetEqual( + self.assertCountEqual( Tag.objects.all(), - ['<Tag: t1>', '<Tag: t2>', '<Tag: t3>', '<Tag: t4>', '<Tag: t5>'], - ordered=False + [self.t1, self.t2, self.t3, self.t4, self.t5], ) finally: Tag._meta.ordering = original_ordering @@ -893,68 +874,59 @@ class Queries1Tests(TestCase): def test_exclude(self): self.assertQuerysetEqual( Item.objects.exclude(tags__name='t4'), - [repr(i) for i in Item.objects.filter(~Q(tags__name='t4'))]) + Item.objects.filter(~Q(tags__name='t4'))) self.assertQuerysetEqual( Item.objects.exclude(Q(tags__name='t4') | Q(tags__name='t3')), - [repr(i) for i in Item.objects.filter(~(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')), - [repr(i) for i in Item.objects.filter(~(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')), - [repr(i) for i in Item.objects.filter(~~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')), - [repr(i) for i in Item.objects.filter(~~Q(tags__name='t4'))]) + Item.objects.filter(~~Q(tags__name='t4'))) self.assertQuerysetEqual( Item.objects.filter(Q(tags__name='t4')), - [repr(i) for i in Item.objects.filter(~Q(~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'])), - [repr(i) for i in Item.objects.filter(~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'])), - [repr(i) for i in 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.assertQuerysetEqual(q, ['<Tag: t1>']) + self.assertSequenceEqual(q, [self.t1]) self.assertNotIn('JOIN', str(q.query)) q = Tag.objects.filter(parent__isnull=False) - self.assertQuerysetEqual( - q, - ['<Tag: t2>', '<Tag: t3>', '<Tag: t4>', '<Tag: t5>'], - ) + 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.assertQuerysetEqual( - q, - ['<Tag: t2>', '<Tag: t3>', '<Tag: t4>', '<Tag: t5>'], - ) + 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.assertQuerysetEqual(q, ['<Tag: t1>']) + self.assertSequenceEqual(q, [self.t1]) self.assertNotIn('JOIN', str(q.query)) q = Tag.objects.exclude(parent__parent__isnull=False) - self.assertQuerysetEqual( - q, - ['<Tag: t1>', '<Tag: t2>', '<Tag: t3>'], - ) + 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)) @@ -963,19 +935,13 @@ class Queries1Tests(TestCase): # while preserving the preceding inner joins. q = Tag.objects.filter(parent__parent__isnull=False) - self.assertQuerysetEqual( - q, - ['<Tag: t4>', '<Tag: t5>'], - ) + 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.assertQuerysetEqual( - q, - ['<Tag: t4>', '<Tag: t5>'], - ) + 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) @@ -985,56 +951,41 @@ class Queries1Tests(TestCase): 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.assertQuerysetEqual(q, []) + 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.assertQuerysetEqual(q, ['<NamedCategory: Generic>']) + 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.assertQuerysetEqual( - q, - ['<Author: a2>', '<Author: a3>'], - ) + 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.assertQuerysetEqual( - q, - ['<Author: a1>', '<Author: a2>', '<Author: a2>', '<Author: a3>'], - ) + 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.assertQuerysetEqual( - q, - ['<Author: a1>', '<Author: a1>', '<Author: a2>', '<Author: a2>', '<Author: a4>'] - ) + 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.assertQuerysetEqual( - q, - ['<Author: a1>', '<Author: a2>', '<Author: a4>'] - ) + 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.assertQuerysetEqual( - q, - ['<Author: a4>'] - ) + self.assertSequenceEqual(q, [self.a4]) self.assertEqual(str(q.query).count('LEFT OUTER JOIN'), 0) self.assertEqual(str(q.query).count('INNER JOIN'), 4) @@ -1042,47 +993,34 @@ class Queries1Tests(TestCase): # 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.assertQuerysetEqual( + self.assertSequenceEqual( q, - ['<Author: a1>', '<Author: a1>', '<Author: a2>', '<Author: a2>', - '<Author: a2>', '<Author: a3>'] + [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.assertQuerysetEqual( - q, - ['<Author: a1>', '<Author: a2>', '<Author: a2>', '<Author: a3>'] - ) + 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.assertQuerysetEqual( - q, - ['<Author: a3>'] - ) + 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.assertQuerysetEqual( - q, - ['<Author: a1>', '<Author: a2>', '<Author: a2>', '<Author: a4>'] - ) + 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.assertQuerysetEqual( - q, - ['<Tag: t1>', '<Tag: t2>', '<Tag: t3>'] - ) + 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) @@ -1092,32 +1030,23 @@ class Queries1Tests(TestCase): q2 = Tag.objects.filter(parent__isnull=False) q3 = q1 | q2 - self.assertQuerysetEqual( - q3, - ['<Tag: t1>', '<Tag: t2>', '<Tag: t3>', '<Tag: t4>', '<Tag: t5>'], - ) + 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.assertQuerysetEqual(q3, []) + 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.assertQuerysetEqual( - q3, - ['<Tag: t1>', '<Tag: t2>', '<Tag: t3>'] - ) + 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.assertQuerysetEqual( - q3, - ['<Tag: t1>', '<Tag: t2>', '<Tag: t3>'] - ) + 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) @@ -1125,25 +1054,19 @@ class Queries1Tests(TestCase): q2 = Tag.objects.filter(parent__parent__isnull=True) q3 = q1 | q2 - self.assertQuerysetEqual( - q3, - ['<Tag: t1>', '<Tag: t2>', '<Tag: t3>'] - ) + 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.assertQuerysetEqual( - q3, - ['<Tag: t1>', '<Tag: t2>', '<Tag: t3>'] - ) + 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.assertQuerysetEqual( + self.assertSequenceEqual( Report.objects.filter(Q(creator__isnull=False) & ~Q(creator__extra__value=41)), - ['<Report: r1>'] + [self.r1], ) def test_ticket_20250(self): @@ -1152,10 +1075,7 @@ class Queries1Tests(TestCase): qs = qs.filter(~Q(extra__value=0)).order_by('name') self.assertIn('SELECT', str(qs.query)) - self.assertQuerysetEqual( - qs, - ['<Author: a1>', '<Author: a2>', '<Author: a3>', '<Author: a4>'] - ) + self.assertSequenceEqual(qs, [self.a1, self.a2, self.a3, self.a4]) def test_lookup_constraint_fielderror(self): msg = ( @@ -1219,99 +1139,91 @@ class Queries1Tests(TestCase): class Queries2Tests(TestCase): @classmethod def setUpTestData(cls): - Number.objects.create(num=4) - Number.objects.create(num=8) - Number.objects.create(num=12) + 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.assertQuerysetEqual(Number.objects.filter(num__lt=4), []) - self.assertQuerysetEqual(Number.objects.filter(num__gt=8, num__lt=12), []) - self.assertQuerysetEqual( + 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), - ['<Number: 12>'] + [self.num12], ) - self.assertQuerysetEqual( + self.assertSequenceEqual( Number.objects.filter(Q(num__lt=4) | Q(num__gt=8, num__lt=12)), [] ) - self.assertQuerysetEqual( + self.assertSequenceEqual( Number.objects.filter(Q(num__gt=8, num__lt=12) | Q(num__lt=4)), [] ) - self.assertQuerysetEqual( + self.assertSequenceEqual( Number.objects.filter(Q(num__gt=8) & Q(num__lt=12) | Q(num__lt=4)), [] ) - self.assertQuerysetEqual( + self.assertSequenceEqual( Number.objects.filter(Q(num__gt=7) & Q(num__lt=12) | Q(num__lt=4)), - ['<Number: 8>'] + [self.num8], ) def test_ticket12239(self): # Custom lookups are registered to round float values correctly on gte # and lt IntegerField queries. - self.assertQuerysetEqual( + self.assertSequenceEqual( Number.objects.filter(num__gt=11.9), - ['<Number: 12>'] + [self.num12], ) - self.assertQuerysetEqual(Number.objects.filter(num__gt=12), []) - self.assertQuerysetEqual(Number.objects.filter(num__gt=12.0), []) - self.assertQuerysetEqual(Number.objects.filter(num__gt=12.1), []) - self.assertQuerysetEqual( + 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), - ['<Number: 4>', '<Number: 8>'], - ordered=False + [self.num4, self.num8], ) - self.assertQuerysetEqual( + self.assertCountEqual( Number.objects.filter(num__lt=12.0), - ['<Number: 4>', '<Number: 8>'], - ordered=False + [self.num4, self.num8], ) - self.assertQuerysetEqual( + self.assertCountEqual( Number.objects.filter(num__lt=12.1), - ['<Number: 4>', '<Number: 8>', '<Number: 12>'], - ordered=False + [self.num4, self.num8, self.num12], ) - self.assertQuerysetEqual( + self.assertCountEqual( Number.objects.filter(num__gte=11.9), - ['<Number: 12>'] + [self.num12], ) - self.assertQuerysetEqual( + self.assertCountEqual( Number.objects.filter(num__gte=12), - ['<Number: 12>'] + [self.num12], ) - self.assertQuerysetEqual( + self.assertCountEqual( Number.objects.filter(num__gte=12.0), - ['<Number: 12>'] + [self.num12], ) - self.assertQuerysetEqual(Number.objects.filter(num__gte=12.1), []) - self.assertQuerysetEqual(Number.objects.filter(num__gte=12.9), []) - self.assertQuerysetEqual( + 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), - ['<Number: 4>', '<Number: 8>'], - ordered=False + [self.num4, self.num8], ) - self.assertQuerysetEqual( + self.assertCountEqual( Number.objects.filter(num__lte=12), - ['<Number: 4>', '<Number: 8>', '<Number: 12>'], - ordered=False + [self.num4, self.num8, self.num12], ) - self.assertQuerysetEqual( + self.assertCountEqual( Number.objects.filter(num__lte=12.0), - ['<Number: 4>', '<Number: 8>', '<Number: 12>'], - ordered=False + [self.num4, self.num8, self.num12], ) - self.assertQuerysetEqual( + self.assertCountEqual( Number.objects.filter(num__lte=12.1), - ['<Number: 4>', '<Number: 8>', '<Number: 12>'], - ordered=False + [self.num4, self.num8, self.num12], ) - self.assertQuerysetEqual( + self.assertCountEqual( Number.objects.filter(num__lte=12.9), - ['<Number: 4>', '<Number: 8>', '<Number: 12>'], - ordered=False + [self.num4, self.num8, self.num12], ) def test_ticket7759(self): @@ -1363,8 +1275,8 @@ class Queries4Tests(TestCase): cls.r2 = Report.objects.create(name='r2', creator=cls.a3) cls.r3 = Report.objects.create(name='r3') - Item.objects.create(name='i1', created=datetime.datetime.now(), note=n1, creator=cls.a1) - Item.objects.create(name='i2', created=datetime.datetime.now(), note=n1, creator=cls.a3) + 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() @@ -1390,12 +1302,12 @@ class Queries4Tests(TestCase): # 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.assertQuerysetEqual(q1, ["<Report: r1>", "<Report: r3>"], ordered=False) + 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.assertQuerysetEqual(q1, ["<Report: r1>", "<Report: r3>"], ordered=False) + 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() @@ -1404,7 +1316,7 @@ class Queries4Tests(TestCase): .filter(Q(creator=self.a1)).order_by() | Item.objects.filter(Q(creator__report__name='r1')) .order_by() ) - self.assertQuerysetEqual(q1, ["<Item: i1>"]) + 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() @@ -1412,7 +1324,7 @@ class Queries4Tests(TestCase): Item.objects.filter(Q(creator__report__name='e1')).order_by() | Item.objects.filter(Q(creator=self.a1)).order_by() ) - self.assertQuerysetEqual(q1, ["<Item: i1>"]) + self.assertCountEqual(q1, [self.i1]) self.assertEqual(str(q1.query), str(q2.query)) def test_combine_join_reuse(self): @@ -1459,9 +1371,9 @@ class Queries4Tests(TestCase): # Similarly for select_related(), joins beyond an initial nullable join # must use outer joins so that all results are included. - self.assertQuerysetEqual( + self.assertSequenceEqual( Report.objects.select_related("creator", "creator__extra").order_by("name"), - ['<Report: r1>', '<Report: r2>', '<Report: r3>'] + [self.r1, self.r2, self.r3] ) # When there are multiple paths to a table from another table, we have @@ -1631,33 +1543,33 @@ class Queries5Tests(TestCase): def setUpTestData(cls): # Ordering by 'rank' gives us rank2, rank1, rank3. Ordering by the # Meta.ordering will be rank3, rank2, rank1. - n1 = Note.objects.create(note='n1', misc='foo', id=1) - n2 = Note.objects.create(note='n2', misc='bar', id=2) - e1 = ExtraInfo.objects.create(info='e1', note=n1) - e2 = ExtraInfo.objects.create(info='e2', note=n2) + 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.rank1 = Ranking.objects.create(rank=2, author=a2) - Ranking.objects.create(rank=1, author=a3) - Ranking.objects.create(rank=3, author=a1) + 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.assertQuerysetEqual( + self.assertSequenceEqual( Ranking.objects.all(), - ['<Ranking: 3: a1>', '<Ranking: 2: a2>', '<Ranking: 1: a3>'] + [self.rank3, self.rank2, self.rank1], ) - self.assertQuerysetEqual( + self.assertSequenceEqual( Ranking.objects.all().order_by('rank'), - ['<Ranking: 1: a3>', '<Ranking: 2: a2>', '<Ranking: 3: a1>'] + [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.assertQuerysetEqual( + self.assertSequenceEqual( Ranking.objects.extra(tables=['django_site'], order_by=['-django_site.id', 'rank']), - ['<Ranking: 1: a3>', '<Ranking: 2: a2>', '<Ranking: 3: a1>'] + [self.rank1, self.rank2, self.rank3], ) sql = 'case when %s > 2 then 1 else 0 end' % connection.ops.quote_name('rank') @@ -1666,9 +1578,9 @@ class Queries5Tests(TestCase): [o.good for o in qs.extra(order_by=('-good',))], [True, False, False] ) - self.assertQuerysetEqual( + self.assertSequenceEqual( qs.extra(order_by=('-good', 'id')), - ['<Ranking: 3: a1>', '<Ranking: 2: a2>', '<Ranking: 1: a3>'] + [self.rank3, self.rank2, self.rank1], ) # Despite having some extra aliases in the query, we can still omit @@ -1707,9 +1619,9 @@ class Queries5Tests(TestCase): ranking_start = Ranking.objects.get(author__name='a1') # Make sure that the IDs from different tables don't happen to match. - self.assertQuerysetEqual( + self.assertSequenceEqual( Ranking.objects.filter(author__name='a1'), - ['<Ranking: 3: a1>'] + [self.rank3], ) self.assertEqual( Ranking.objects.filter(author__name='a1').update(rank=4636), @@ -1722,28 +1634,28 @@ class Queries5Tests(TestCase): self.assertEqual(r.rank, 4636) r.rank = 3 r.save() - self.assertQuerysetEqual( + self.assertSequenceEqual( Ranking.objects.all(), - ['<Ranking: 3: a1>', '<Ranking: 2: a2>', '<Ranking: 1: a3>'] + [self.rank3, self.rank2, self.rank1], ) def test_ticket5261(self): # Test different empty excludes. - self.assertQuerysetEqual( + self.assertSequenceEqual( Note.objects.exclude(Q()), - ['<Note: n1>', '<Note: n2>'] + [self.n1, self.n2], ) - self.assertQuerysetEqual( + self.assertSequenceEqual( Note.objects.filter(~Q()), - ['<Note: n1>', '<Note: n2>'] + [self.n1, self.n2], ) - self.assertQuerysetEqual( + self.assertSequenceEqual( Note.objects.filter(~Q() | ~Q()), - ['<Note: n1>', '<Note: n2>'] + [self.n1, self.n2], ) - self.assertQuerysetEqual( + self.assertSequenceEqual( Note.objects.exclude(~Q() & ~Q()), - ['<Note: n1>', '<Note: n2>'] + [self.n1, self.n2], ) def test_extra_select_literal_percent_s(self): @@ -1796,11 +1708,8 @@ class NullableRelOrderingTests(TestCase): def test_ticket10028(self): # Ordering by model related to nullable relations(!) should use outer # joins, so that all results are included. - Plaything.objects.create(name="p1") - self.assertQuerysetEqual( - Plaything.objects.all(), - ['<Plaything: p1>'] - ) + 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 @@ -1808,7 +1717,7 @@ class NullableRelOrderingTests(TestCase): Plaything.objects.create(name="p1") s = SingleObject.objects.create(name='s') r = RelatedObject.objects.create(single=s, f=1) - Plaything.objects.create(name="p2", others=r) + p2 = Plaything.objects.create(name="p2", others=r) qs = Plaything.objects.all().filter(others__isnull=False).order_by('pk') self.assertNotIn('JOIN', str(qs.query)) qs = Plaything.objects.all().filter(others__f__isnull=False).order_by('pk') @@ -1820,39 +1729,36 @@ class NullableRelOrderingTests(TestCase): # in the query. self.assertEqual(str(qs.query).count('LEFT'), 1) self.assertEqual(str(qs.query).count('INNER'), 1) - self.assertQuerysetEqual( - qs, - ['<Plaything: p2>'] - ) + self.assertSequenceEqual(qs, [p2]) class DisjunctiveFilterTests(TestCase): @classmethod def setUpTestData(cls): cls.n1 = Note.objects.create(note='n1', misc='foo', id=1) - ExtraInfo.objects.create(info='e1', note=cls.n1) + 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. - LeafA.objects.create(data='first') - self.assertQuerysetEqual(LeafA.objects.all(), ['<LeafA: first>']) - self.assertQuerysetEqual( + 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')), - ['<LeafA: first>'] + [l1], ) def test_ticket8283(self): # Checking that applying filters after a disjunction works correctly. - self.assertQuerysetEqual( + self.assertSequenceEqual( (ExtraInfo.objects.filter(note=self.n1) | ExtraInfo.objects.filter(info='e2')).filter(note=self.n1), - ['<ExtraInfo: e1>'] + [self.e1], ) - self.assertQuerysetEqual( + self.assertSequenceEqual( (ExtraInfo.objects.filter(info='e2') | ExtraInfo.objects.filter(note=self.n1)).filter(note=self.n1), - ['<ExtraInfo: e1>'] + [self.e1], ) @@ -1866,9 +1772,9 @@ class Queries6Tests(TestCase): 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) - ann1 = Annotation.objects.create(name='a1', tag=cls.t1) - ann1.notes.add(n1) - Annotation.objects.create(name='a2', tag=cls.t4) + 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. @@ -1899,40 +1805,40 @@ class Queries6Tests(TestCase): # queries that crossed multi-valued relations (#8921, #9188 and some # preemptively discovered cases). - self.assertQuerysetEqual( + self.assertSequenceEqual( PointerA.objects.filter(connection__pointerb__id=1), [] ) - self.assertQuerysetEqual( + self.assertSequenceEqual( PointerA.objects.exclude(connection__pointerb__id=1), [] ) - self.assertQuerysetEqual( + self.assertSequenceEqual( Tag.objects.exclude(children=None), - ['<Tag: t1>', '<Tag: t3>'] + [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.assertQuerysetEqual( + self.assertSequenceEqual( Tag.objects.exclude(parent__annotation__name="a1"), - ['<Tag: t1>', '<Tag: t4>', '<Tag: t5>'] + [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.assertQuerysetEqual( + self.assertSequenceEqual( Annotation.objects.exclude(tag__children__name="t2"), - ['<Annotation: a2>'] + [self.ann2], ) # Nested queries are possible (although should be used with care, since # they have performance problems on backends like MySQL. - self.assertQuerysetEqual( + self.assertSequenceEqual( Annotation.objects.filter(notes__in=Note.objects.filter(note="n1")), - ['<Annotation: a1>'] + [self.ann1], ) def test_ticket3739(self): @@ -2000,23 +1906,23 @@ class ComparisonTests(TestCase): def test_ticket8597(self): # Regression tests for case-insensitive comparisons - Item.objects.create(name="a_b", created=datetime.datetime.now(), creator=self.a2, note=self.n1) - Item.objects.create(name="x%y", created=datetime.datetime.now(), creator=self.a2, note=self.n1) - self.assertQuerysetEqual( + 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: a_b>'] + [item_ab], ) - self.assertQuerysetEqual( + self.assertSequenceEqual( Item.objects.filter(name__iexact="x%Y"), - ['<Item: x%y>'] + [item_xy], ) - self.assertQuerysetEqual( + self.assertSequenceEqual( Item.objects.filter(name__istartswith="A_b"), - ['<Item: a_b>'] + [item_ab], ) - self.assertQuerysetEqual( + self.assertSequenceEqual( Item.objects.filter(name__iendswith="A_b"), - ['<Item: a_b>'] + [item_ab], ) @@ -2411,27 +2317,28 @@ class QuerySetSupportsPythonIdioms(TestCase): @classmethod def setUpTestData(cls): some_date = datetime.datetime(2014, 5, 16, 12, 1) - for i in range(1, 8): - Article.objects.create( - name="Article {}".format(i), created=some_date) + 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.all().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.assertQuerysetEqual( + self.assertSequenceEqual( self.get_ordered_articles()[1:3], - ["<Article: Article 2>", "<Article: Article 3>"] + [self.articles[1], self.articles[2]], ) def test_slicing_with_steps_can_be_used(self): - self.assertQuerysetEqual( + self.assertSequenceEqual( self.get_ordered_articles()[::2], [ - "<Article: Article 1>", - "<Article: Article 3>", - "<Article: Article 5>", - "<Article: Article 7>" + self.articles[0], + self.articles[2], + self.articles[4], + self.articles[6], ] ) @@ -2444,28 +2351,28 @@ class QuerySetSupportsPythonIdioms(TestCase): self.get_ordered_articles()[0:5:3] def test_slicing_can_slice_again_after_slicing(self): - self.assertQuerysetEqual( + self.assertSequenceEqual( self.get_ordered_articles()[0:5][0:2], - ["<Article: Article 1>", "<Article: Article 2>"] + [self.articles[0], self.articles[1]], ) - self.assertQuerysetEqual(self.get_ordered_articles()[0:5][4:], ["<Article: Article 5>"]) - self.assertQuerysetEqual(self.get_ordered_articles()[0:5][5:], []) + 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.assertQuerysetEqual( + self.assertSequenceEqual( self.get_ordered_articles()[2:][0:2], - ["<Article: Article 3>", "<Article: Article 4>"] + [self.articles[2], self.articles[3]], ) - self.assertQuerysetEqual( + self.assertSequenceEqual( self.get_ordered_articles()[2:][:2], - ["<Article: Article 3>", "<Article: Article 4>"] + [self.articles[2], self.articles[3]], ) - self.assertQuerysetEqual(self.get_ordered_articles()[2:][2:3], ["<Article: Article 5>"]) + self.assertSequenceEqual(self.get_ordered_articles()[2:][2:3], [self.articles[4]]) # Using an offset without a limit is also possible. - self.assertQuerysetEqual( + self.assertSequenceEqual( self.get_ordered_articles()[5:], - ["<Article: Article 6>", "<Article: Article 7>"] + [self.articles[5], self.articles[6]], ) def test_slicing_cannot_filter_queryset_once_sliced(self): @@ -2501,11 +2408,11 @@ class QuerySetSupportsPythonIdioms(TestCase): 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.assertQuerysetEqual( + self.assertSequenceEqual( (s1 | s2).order_by('name'), - ["<Article: Article 1>", "<Article: Article 2>"] + [self.articles[0], self.articles[1]], ) - self.assertQuerysetEqual(s1 & s2, []) + self.assertSequenceEqual(s1 & s2, []) class WeirdQuerysetSlicingTests(TestCase): @@ -2550,15 +2457,15 @@ class WeirdQuerysetSlicingTests(TestCase): class EscapingTests(TestCase): def test_ticket_7302(self): # Reserved names are appropriately escaped - ReservedName.objects.create(name='a', order=42) - ReservedName.objects.create(name='b', order=37) - self.assertQuerysetEqual( + r_a = ReservedName.objects.create(name='a', order=42) + r_b = ReservedName.objects.create(name='b', order=37) + self.assertSequenceEqual( ReservedName.objects.all().order_by('order'), - ['<ReservedName: b>', '<ReservedName: a>'] + [r_b, r_a], ) - self.assertQuerysetEqual( + self.assertSequenceEqual( ReservedName.objects.extra(select={'stuff': 'name'}, order_by=('order', 'stuff')), - ['<ReservedName: b>', '<ReservedName: a>'] + [r_b, r_a], ) @@ -2661,15 +2568,15 @@ class IsNullTests(TestCase): def test_to_field(self): apple = Food.objects.create(name="apple") - Eaten.objects.create(food=apple, meal="lunch") - Eaten.objects.create(meal="lunch") - self.assertQuerysetEqual( + e1 = Eaten.objects.create(food=apple, meal="lunch") + e2 = Eaten.objects.create(meal="lunch") + self.assertSequenceEqual( Eaten.objects.filter(food__isnull=False), - ['<Eaten: apple at lunch>'] + [e1], ) - self.assertQuerysetEqual( + self.assertSequenceEqual( Eaten.objects.filter(food__isnull=True), - ['<Eaten: None at lunch>'] + [e2], ) @@ -2805,25 +2712,28 @@ class ExcludeTests(TestCase): @classmethod def setUpTestData(cls): f1 = Food.objects.create(name='apples') - Food.objects.create(name='oranges') + 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') - j2 = Job.objects.create(name='Programmer') - r2 = Responsibility.objects.create(description='Programming') + 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=j2, responsibility=r2) + JobResponsibilities.objects.create(job=cls.j2, responsibility=cls.r2) def test_to_field(self): - self.assertQuerysetEqual( + self.assertSequenceEqual( Food.objects.exclude(eaten__meal='dinner'), - ['<Food: oranges>']) - self.assertQuerysetEqual( + [self.f2], + ) + self.assertSequenceEqual( Job.objects.exclude(responsibilities__description='Playing golf'), - ['<Job: Programmer>']) - self.assertQuerysetEqual( + [self.j2], + ) + self.assertSequenceEqual( Responsibility.objects.exclude(jobs__name='Manager'), - ['<Responsibility: Programming>']) + [self.r2], + ) def test_ticket14511(self): alex = Person.objects.get_or_create(name='Alex')[0] @@ -2927,33 +2837,37 @@ class ExcludeTest17600(TestCase): """ This should exclude Orders which have some items with status 1 """ - self.assertQuerysetEqual( + self.assertSequenceEqual( Order.objects.exclude(items__status=1), - ['<Order: 3>']) + [self.o3], + ) def test_exclude_plain_distinct(self): """ This should exclude Orders which have some items with status 1 """ - self.assertQuerysetEqual( + self.assertSequenceEqual( Order.objects.exclude(items__status=1).distinct(), - ['<Order: 3>']) + [self.o3], + ) def test_exclude_with_q_object_distinct(self): """ This should exclude Orders which have some items with status 1 """ - self.assertQuerysetEqual( + self.assertSequenceEqual( Order.objects.exclude(Q(items__status=1)).distinct(), - ['<Order: 3>']) + [self.o3], + ) def test_exclude_with_q_object_no_distinct(self): """ This should exclude Orders which have some items with status 1 """ - self.assertQuerysetEqual( + self.assertSequenceEqual( Order.objects.exclude(Q(items__status=1)), - ['<Order: 3>']) + [self.o3], + ) def test_exclude_with_q_is_equal_to_plain_exclude(self): """ @@ -2982,7 +2896,8 @@ class ExcludeTest17600(TestCase): """ self.assertQuerysetEqual( Order.objects.exclude(~Q(items__status=1)).distinct(), - ['<Order: 1>']) + [self.o1], + ) class Exclude15786(TestCase): @@ -3528,20 +3443,22 @@ class DisjunctionPromotionTests(TestCase): class ManyToManyExcludeTest(TestCase): def test_exclude_many_to_many(self): - Identifier.objects.create(name='extra') - program = Program.objects.create(identifier=Identifier.objects.create(name='program')) - channel = Channel.objects.create(identifier=Identifier.objects.create(name='channel')) + 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.assertQuerysetEqual( + self.assertSequenceEqual( Identifier.objects.exclude(program__channel=channel).order_by('name'), - ['<Identifier: channel>', '<Identifier: extra>'] + [i_channel, i_extra], ) - self.assertQuerysetEqual( + self.assertSequenceEqual( Identifier.objects.exclude(program__channel=None).order_by('name'), - ['<Identifier: program>'] + [i_program], ) def test_ticket_12823(self): @@ -3687,9 +3604,9 @@ class RelatedLookupTypeTests(TestCase): 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) - ProxyObjectB.objects.create(name="pob", objecta=cls.oa, num=2) + cls.pob1 = ProxyObjectB.objects.create(name="pob", objecta=cls.oa, num=2) cls.pob = ProxyObjectB.objects.all() - ObjectC.objects.create(childobjecta=cls.coa) + cls.c = ObjectC.objects.create(childobjecta=cls.coa) def test_wrong_type_lookup(self): """ @@ -3735,24 +3652,24 @@ class RelatedLookupTypeTests(TestCase): When passing proxy model objects, child objects, or parent objects, lookups work fine. """ - out_a = ['<ObjectA: oa>'] - out_b = ['<ObjectB: ob>', '<ObjectB: pob>'] - out_c = ['<ObjectC: >'] + out_a = [self.oa] + out_b = [self.ob, self.pob1] + out_c = [self.c] # proxy model objects - self.assertQuerysetEqual(ObjectB.objects.filter(objecta=self.poa).order_by('name'), out_b) - self.assertQuerysetEqual(ObjectA.objects.filter(objectb__in=self.pob).order_by('pk'), out_a * 2) + 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.assertQuerysetEqual(ObjectB.objects.filter(objecta__in=[self.coa]), []) - self.assertQuerysetEqual(ObjectB.objects.filter(objecta__in=[self.poa, self.coa]).order_by('name'), out_b) - self.assertQuerysetEqual( + 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.assertQuerysetEqual(ObjectC.objects.exclude(childobjecta=self.oa), out_c) + 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). @@ -3770,9 +3687,9 @@ class RelatedLookupTypeTests(TestCase): pob = ObjectB.objects.get(name='pob') pob.num = pob.objecta.pk pob.save() - self.assertQuerysetEqual(ObjectB.objects.filter( + self.assertSequenceEqual(ObjectB.objects.filter( objecta__in=ObjectB.objects.all().values_list('num') - ).order_by('pk'), ['<ObjectB: ob>', '<ObjectB: pob>']) + ).order_by('pk'), [ob, pob]) class Ticket14056Tests(TestCase): diff --git a/tests/select_related_regress/tests.py b/tests/select_related_regress/tests.py index 753114a6d2..47e5e4f3c9 100644 --- a/tests/select_related_regress/tests.py +++ b/tests/select_related_regress/tests.py @@ -100,12 +100,12 @@ class SelectRelatedRegressTests(TestCase): def test_multi_table_inheritance(self): """ Exercising select_related() with multi-table model inheritance. """ c1 = Child.objects.create(name="child1", value=42) - Item.objects.create(name="item1", child=c1) - Item.objects.create(name="item2") + i1 = Item.objects.create(name="item1", child=c1) + i2 = Item.objects.create(name="item2") - self.assertQuerysetEqual( + self.assertSequenceEqual( Item.objects.select_related("child").order_by("name"), - ["<Item: item1>", "<Item: item2>"] + [i1, i2], ) def test_regression_12851(self): diff --git a/tests/test_utils/tests.py b/tests/test_utils/tests.py index 51e3c0548a..9255315e98 100644 --- a/tests/test_utils/tests.py +++ b/tests/test_utils/tests.py @@ -16,8 +16,8 @@ from django.forms import EmailField, IntegerField from django.http import HttpResponse from django.template.loader import render_to_string from django.test import ( - SimpleTestCase, TestCase, TransactionTestCase, skipIfDBFeature, - skipUnlessDBFeature, + SimpleTestCase, TestCase, TransactionTestCase, ignore_warnings, + skipIfDBFeature, skipUnlessDBFeature, ) from django.test.html import HTMLParseError, parse_html from django.test.utils import ( @@ -25,6 +25,7 @@ from django.test.utils import ( override_settings, setup_test_environment, ) from django.urls import NoReverseMatch, path, reverse, reverse_lazy +from django.utils.deprecation import RemovedInDjango41Warning from .models import Car, Person, PossessedCar from .views import empty_response @@ -243,19 +244,34 @@ class AssertQuerysetEqualTests(TestCase): cls.p1 = Person.objects.create(name='p1') cls.p2 = Person.objects.create(name='p2') + def test_empty(self): + self.assertQuerysetEqual(Person.objects.filter(name='p3'), []) + def test_ordered(self): self.assertQuerysetEqual( Person.objects.all().order_by('name'), - [repr(self.p1), repr(self.p2)] + [self.p1, self.p2], ) def test_unordered(self): self.assertQuerysetEqual( Person.objects.all().order_by('name'), - [repr(self.p2), repr(self.p1)], + [self.p2, self.p1], ordered=False ) + def test_queryset(self): + self.assertQuerysetEqual( + Person.objects.all().order_by('name'), + Person.objects.all().order_by('name'), + ) + + def test_flat_values_list(self): + self.assertQuerysetEqual( + Person.objects.all().order_by('name').values_list('name', flat=True), + ['p1', 'p2'], + ) + def test_transform(self): self.assertQuerysetEqual( Person.objects.all().order_by('name'), @@ -263,6 +279,13 @@ class AssertQuerysetEqualTests(TestCase): transform=lambda x: x.pk ) + def test_repr_transform(self): + self.assertQuerysetEqual( + Person.objects.all().order_by('name'), + [repr(self.p1), repr(self.p2)], + transform=repr, + ) + def test_undefined_order(self): # Using an unordered queryset with more than one ordered value # is an error. @@ -270,13 +293,10 @@ class AssertQuerysetEqualTests(TestCase): with self.assertRaisesMessage(ValueError, msg): self.assertQuerysetEqual( Person.objects.all(), - [repr(self.p1), repr(self.p2)] + [self.p1, self.p2], ) # No error for one value. - self.assertQuerysetEqual( - Person.objects.filter(name='p1'), - [repr(self.p1)] - ) + self.assertQuerysetEqual(Person.objects.filter(name='p1'), [self.p1]) def test_repeated_values(self): """ @@ -296,16 +316,42 @@ class AssertQuerysetEqualTests(TestCase): with self.assertRaises(AssertionError): self.assertQuerysetEqual( self.p1.cars.all(), - [repr(batmobile), repr(k2000)], + [batmobile, k2000], ordered=False ) self.assertQuerysetEqual( self.p1.cars.all(), - [repr(batmobile)] * 2 + [repr(k2000)] * 4, + [batmobile] * 2 + [k2000] * 4, ordered=False ) +class AssertQuerysetEqualDeprecationTests(TestCase): + @classmethod + def setUpTestData(cls): + cls.p1 = Person.objects.create(name='p1') + cls.p2 = Person.objects.create(name='p2') + + @ignore_warnings(category=RemovedInDjango41Warning) + def test_str_values(self): + self.assertQuerysetEqual( + Person.objects.all().order_by('name'), + [repr(self.p1), repr(self.p2)], + ) + + def test_str_values_warning(self): + msg = ( + "In Django 4.1, repr() will not be called automatically on a " + "queryset when compared to string values. Set an explicit " + "'transform' to silence this warning." + ) + with self.assertRaisesMessage(RemovedInDjango41Warning, msg): + self.assertQuerysetEqual( + Person.objects.all().order_by('name'), + [repr(self.p1), repr(self.p2)], + ) + + @override_settings(ROOT_URLCONF='test_utils.urls') class CaptureQueriesContextManagerTests(TestCase): diff --git a/tests/transactions/tests.py b/tests/transactions/tests.py index 2ac2f8cc84..a4d64222be 100644 --- a/tests/transactions/tests.py +++ b/tests/transactions/tests.py @@ -32,9 +32,9 @@ class AtomicTests(TransactionTestCase): def test_decorator_syntax_commit(self): @transaction.atomic def make_reporter(): - Reporter.objects.create(first_name="Tintin") - make_reporter() - self.assertQuerysetEqual(Reporter.objects.all(), ['<Reporter: Tintin>']) + return Reporter.objects.create(first_name="Tintin") + reporter = make_reporter() + self.assertSequenceEqual(Reporter.objects.all(), [reporter]) def test_decorator_syntax_rollback(self): @transaction.atomic @@ -43,14 +43,14 @@ class AtomicTests(TransactionTestCase): raise Exception("Oops, that's his last name") with self.assertRaisesMessage(Exception, "Oops"): make_reporter() - self.assertQuerysetEqual(Reporter.objects.all(), []) + self.assertSequenceEqual(Reporter.objects.all(), []) def test_alternate_decorator_syntax_commit(self): @transaction.atomic() def make_reporter(): - Reporter.objects.create(first_name="Tintin") - make_reporter() - self.assertQuerysetEqual(Reporter.objects.all(), ['<Reporter: Tintin>']) + return Reporter.objects.create(first_name="Tintin") + reporter = make_reporter() + self.assertSequenceEqual(Reporter.objects.all(), [reporter]) def test_alternate_decorator_syntax_rollback(self): @transaction.atomic() @@ -59,38 +59,35 @@ class AtomicTests(TransactionTestCase): raise Exception("Oops, that's his last name") with self.assertRaisesMessage(Exception, "Oops"): make_reporter() - self.assertQuerysetEqual(Reporter.objects.all(), []) + self.assertSequenceEqual(Reporter.objects.all(), []) def test_commit(self): with transaction.atomic(): - Reporter.objects.create(first_name="Tintin") - self.assertQuerysetEqual(Reporter.objects.all(), ['<Reporter: Tintin>']) + reporter = Reporter.objects.create(first_name="Tintin") + self.assertSequenceEqual(Reporter.objects.all(), [reporter]) def test_rollback(self): with self.assertRaisesMessage(Exception, "Oops"): with transaction.atomic(): Reporter.objects.create(first_name="Haddock") raise Exception("Oops, that's his last name") - self.assertQuerysetEqual(Reporter.objects.all(), []) + self.assertSequenceEqual(Reporter.objects.all(), []) def test_nested_commit_commit(self): with transaction.atomic(): - Reporter.objects.create(first_name="Tintin") + reporter1 = Reporter.objects.create(first_name="Tintin") with transaction.atomic(): - Reporter.objects.create(first_name="Archibald", last_name="Haddock") - self.assertQuerysetEqual( - Reporter.objects.all(), - ['<Reporter: Archibald Haddock>', '<Reporter: Tintin>'] - ) + reporter2 = Reporter.objects.create(first_name="Archibald", last_name="Haddock") + self.assertSequenceEqual(Reporter.objects.all(), [reporter2, reporter1]) def test_nested_commit_rollback(self): with transaction.atomic(): - Reporter.objects.create(first_name="Tintin") + reporter = Reporter.objects.create(first_name="Tintin") with self.assertRaisesMessage(Exception, "Oops"): with transaction.atomic(): Reporter.objects.create(first_name="Haddock") raise Exception("Oops, that's his last name") - self.assertQuerysetEqual(Reporter.objects.all(), ['<Reporter: Tintin>']) + self.assertSequenceEqual(Reporter.objects.all(), [reporter]) def test_nested_rollback_commit(self): with self.assertRaisesMessage(Exception, "Oops"): @@ -99,7 +96,7 @@ class AtomicTests(TransactionTestCase): with transaction.atomic(): Reporter.objects.create(last_name="Haddock") raise Exception("Oops, that's his first name") - self.assertQuerysetEqual(Reporter.objects.all(), []) + self.assertSequenceEqual(Reporter.objects.all(), []) def test_nested_rollback_rollback(self): with self.assertRaisesMessage(Exception, "Oops"): @@ -110,17 +107,14 @@ class AtomicTests(TransactionTestCase): Reporter.objects.create(first_name="Haddock") raise Exception("Oops, that's his last name") raise Exception("Oops, that's his first name") - self.assertQuerysetEqual(Reporter.objects.all(), []) + self.assertSequenceEqual(Reporter.objects.all(), []) def test_merged_commit_commit(self): with transaction.atomic(): - Reporter.objects.create(first_name="Tintin") + reporter1 = Reporter.objects.create(first_name="Tintin") with transaction.atomic(savepoint=False): - Reporter.objects.create(first_name="Archibald", last_name="Haddock") - self.assertQuerysetEqual( - Reporter.objects.all(), - ['<Reporter: Archibald Haddock>', '<Reporter: Tintin>'] - ) + reporter2 = Reporter.objects.create(first_name="Archibald", last_name="Haddock") + self.assertSequenceEqual(Reporter.objects.all(), [reporter2, reporter1]) def test_merged_commit_rollback(self): with transaction.atomic(): @@ -130,7 +124,7 @@ class AtomicTests(TransactionTestCase): Reporter.objects.create(first_name="Haddock") raise Exception("Oops, that's his last name") # Writes in the outer block are rolled back too. - self.assertQuerysetEqual(Reporter.objects.all(), []) + self.assertSequenceEqual(Reporter.objects.all(), []) def test_merged_rollback_commit(self): with self.assertRaisesMessage(Exception, "Oops"): @@ -139,7 +133,7 @@ class AtomicTests(TransactionTestCase): with transaction.atomic(savepoint=False): Reporter.objects.create(last_name="Haddock") raise Exception("Oops, that's his first name") - self.assertQuerysetEqual(Reporter.objects.all(), []) + self.assertSequenceEqual(Reporter.objects.all(), []) def test_merged_rollback_rollback(self): with self.assertRaisesMessage(Exception, "Oops"): @@ -150,25 +144,25 @@ class AtomicTests(TransactionTestCase): Reporter.objects.create(first_name="Haddock") raise Exception("Oops, that's his last name") raise Exception("Oops, that's his first name") - self.assertQuerysetEqual(Reporter.objects.all(), []) + self.assertSequenceEqual(Reporter.objects.all(), []) def test_reuse_commit_commit(self): atomic = transaction.atomic() with atomic: - Reporter.objects.create(first_name="Tintin") + reporter1 = Reporter.objects.create(first_name="Tintin") with atomic: - Reporter.objects.create(first_name="Archibald", last_name="Haddock") - self.assertQuerysetEqual(Reporter.objects.all(), ['<Reporter: Archibald Haddock>', '<Reporter: Tintin>']) + reporter2 = Reporter.objects.create(first_name="Archibald", last_name="Haddock") + self.assertSequenceEqual(Reporter.objects.all(), [reporter2, reporter1]) def test_reuse_commit_rollback(self): atomic = transaction.atomic() with atomic: - Reporter.objects.create(first_name="Tintin") + reporter = Reporter.objects.create(first_name="Tintin") with self.assertRaisesMessage(Exception, "Oops"): with atomic: Reporter.objects.create(first_name="Haddock") raise Exception("Oops, that's his last name") - self.assertQuerysetEqual(Reporter.objects.all(), ['<Reporter: Tintin>']) + self.assertSequenceEqual(Reporter.objects.all(), [reporter]) def test_reuse_rollback_commit(self): atomic = transaction.atomic() @@ -178,7 +172,7 @@ class AtomicTests(TransactionTestCase): with atomic: Reporter.objects.create(last_name="Haddock") raise Exception("Oops, that's his first name") - self.assertQuerysetEqual(Reporter.objects.all(), []) + self.assertSequenceEqual(Reporter.objects.all(), []) def test_reuse_rollback_rollback(self): atomic = transaction.atomic() @@ -190,7 +184,7 @@ class AtomicTests(TransactionTestCase): Reporter.objects.create(first_name="Haddock") raise Exception("Oops, that's his last name") raise Exception("Oops, that's his first name") - self.assertQuerysetEqual(Reporter.objects.all(), []) + self.assertSequenceEqual(Reporter.objects.all(), []) def test_force_rollback(self): with transaction.atomic(): @@ -198,11 +192,11 @@ class AtomicTests(TransactionTestCase): # atomic block shouldn't rollback, but force it. self.assertFalse(transaction.get_rollback()) transaction.set_rollback(True) - self.assertQuerysetEqual(Reporter.objects.all(), []) + self.assertSequenceEqual(Reporter.objects.all(), []) def test_prevent_rollback(self): with transaction.atomic(): - Reporter.objects.create(first_name="Tintin") + reporter = Reporter.objects.create(first_name="Tintin") sid = transaction.savepoint() # trigger a database error inside an inner atomic without savepoint with self.assertRaises(DatabaseError): @@ -214,7 +208,7 @@ class AtomicTests(TransactionTestCase): self.assertTrue(transaction.get_rollback()) transaction.set_rollback(False) transaction.savepoint_rollback(sid) - self.assertQuerysetEqual(Reporter.objects.all(), ['<Reporter: Tintin>']) + self.assertSequenceEqual(Reporter.objects.all(), [reporter]) class AtomicInsideTransactionTests(AtomicTests): @@ -269,11 +263,11 @@ class AtomicMergeTests(TransactionTestCase): self.assertEqual(Reporter.objects.count(), 3) transaction.set_rollback(True) # The first block has a savepoint and must roll back. - self.assertQuerysetEqual(Reporter.objects.all(), []) + self.assertSequenceEqual(Reporter.objects.all(), []) def test_merged_inner_savepoint_rollback(self): with transaction.atomic(): - Reporter.objects.create(first_name="Tintin") + reporter = Reporter.objects.create(first_name="Tintin") with transaction.atomic(): Reporter.objects.create(first_name="Archibald", last_name="Haddock") with self.assertRaisesMessage(Exception, "Oops"): @@ -288,7 +282,7 @@ class AtomicMergeTests(TransactionTestCase): transaction.set_rollback(True) # The second block has a savepoint and must roll back. self.assertEqual(Reporter.objects.count(), 1) - self.assertQuerysetEqual(Reporter.objects.all(), ['<Reporter: Tintin>']) + self.assertSequenceEqual(Reporter.objects.all(), [reporter]) @skipUnlessDBFeature('uses_savepoints') |