mirrors/django
1
0
Fork 0
mirror of https://github.com/django/django.git synced 2025-08-04 10:59:45 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 4

Refs #33476 -- Reformatted code with Black.

Browse source
This commit is contained in:
django-bot 2022-02-03 20:24:19 +01:00 • committed by Mariusz Felisiak
parent f68fa8b45d
commit 9c19aff7c7
1992 changed files with 139577 additions and 96284 deletions
Download patch file Download diff file Expand all files Collapse all files

189
tests/raw_query/tests.py
View file

@ -6,51 +6,80 @@ from django.db.models.query import RawQuerySet
from django.test import TestCase, skipUnlessDBFeature
from .models import (
Author, Book, BookFkAsPk, Coffee, FriendlyAuthor, MixedCaseIDColumn,
Author,
Book,
BookFkAsPk,
Coffee,
FriendlyAuthor,
MixedCaseIDColumn,
Reviewer,
)
class RawQueryTests(TestCase):
@classmethod
def setUpTestData(cls):
cls.a1 = Author.objects.create(first_name='Joe', last_name='Smith', dob=date(1950, 9, 20))
cls.a2 = Author.objects.create(first_name='Jill', last_name='Doe', dob=date(1920, 4, 2))
cls.a3 = Author.objects.create(first_name='Bob', last_name='Smith', dob=date(1986, 1, 25))
cls.a4 = Author.objects.create(first_name='Bill', last_name='Jones', dob=date(1932, 5, 10))
cls.a1 = Author.objects.create(
first_name="Joe", last_name="Smith", dob=date(1950, 9, 20)
)
cls.a2 = Author.objects.create(
first_name="Jill", last_name="Doe", dob=date(1920, 4, 2)
)
cls.a3 = Author.objects.create(
first_name="Bob", last_name="Smith", dob=date(1986, 1, 25)
)
cls.a4 = Author.objects.create(
first_name="Bill", last_name="Jones", dob=date(1932, 5, 10)
)
cls.b1 = Book.objects.create(
title='The awesome book', author=cls.a1, paperback=False,
opening_line='It was a bright cold day in April and the clocks were striking thirteen.',
title="The awesome book",
author=cls.a1,
paperback=False,
opening_line="It was a bright cold day in April and the clocks were striking thirteen.",
)
cls.b2 = Book.objects.create(
title='The horrible book', author=cls.a1, paperback=True,
title="The horrible book",
author=cls.a1,
paperback=True,
opening_line=(
'On an evening in the latter part of May a middle-aged man '
'was walking homeward from Shaston to the village of Marlott, '
'in the adjoining Vale of Blakemore, or Blackmoor.'
"On an evening in the latter part of May a middle-aged man "
"was walking homeward from Shaston to the village of Marlott, "
"in the adjoining Vale of Blakemore, or Blackmoor."
),
)
cls.b3 = Book.objects.create(
title='Another awesome book', author=cls.a1, paperback=False,
opening_line='A squat gray building of only thirty-four stories.',
title="Another awesome book",
author=cls.a1,
paperback=False,
opening_line="A squat gray building of only thirty-four stories.",
)
cls.b4 = Book.objects.create(
title='Some other book', author=cls.a3, paperback=True,
opening_line='It was the day my grandmother exploded.',
title="Some other book",
author=cls.a3,
paperback=True,
opening_line="It was the day my grandmother exploded.",
)
cls.c1 = Coffee.objects.create(brand='dunkin doughnuts')
cls.c2 = Coffee.objects.create(brand='starbucks')
cls.c1 = Coffee.objects.create(brand="dunkin doughnuts")
cls.c2 = Coffee.objects.create(brand="starbucks")
cls.r1 = Reviewer.objects.create()
cls.r2 = Reviewer.objects.create()
cls.r1.reviewed.add(cls.b2, cls.b3, cls.b4)
def assertSuccessfulRawQuery(self, model, query, expected_results,
expected_annotations=(), params=[], translations=None):
def assertSuccessfulRawQuery(
self,
model,
query,
expected_results,
expected_annotations=(),
params=[],
translations=None,
):
"""
Execute the passed query against the passed model and check the output
"""
results = list(model.objects.raw(query, params=params, translations=translations))
results = list(
model.objects.raw(query, params=params, translations=translations)
)
self.assertProcessed(model, results, expected_results, expected_annotations)
self.assertAnnotations(results, expected_annotations)
@ -67,13 +96,12 @@ class RawQueryTests(TestCase):
for field in model._meta.fields:
# All values on the model are equal
self.assertEqual(
getattr(item, field.attname),
getattr(orig_item, field.attname)
getattr(item, field.attname), getattr(orig_item, field.attname)
)
# This includes checking that they are the same type
self.assertEqual(
type(getattr(item, field.attname)),
type(getattr(orig_item, field.attname))
type(getattr(orig_item, field.attname)),
)
def assertNoAnnotations(self, results):
@ -93,9 +121,13 @@ class RawQueryTests(TestCase):
self.assertEqual(getattr(result, annotation), value)
def test_rawqueryset_repr(self):
queryset = RawQuerySet(raw_query='SELECT * FROM raw_query_author')
self.assertEqual(repr(queryset), '<RawQuerySet: SELECT * FROM raw_query_author>')
self.assertEqual(repr(queryset.query), '<RawQuery: SELECT * FROM raw_query_author>')
queryset = RawQuerySet(raw_query="SELECT * FROM raw_query_author")
self.assertEqual(
repr(queryset), "<RawQuerySet: SELECT * FROM raw_query_author>"
)
self.assertEqual(
repr(queryset.query), "<RawQuery: SELECT * FROM raw_query_author>"
)
def test_simple_raw_query(self):
"""
@ -110,7 +142,7 @@ class RawQueryTests(TestCase):
Raw queries are lazy: they aren't actually executed until they're
iterated over.
"""
q = Author.objects.raw('SELECT * FROM raw_query_author')
q = Author.objects.raw("SELECT * FROM raw_query_author")
self.assertIsNone(q.query.cursor)
list(q)
self.assertIsNotNone(q.query.cursor)
@ -146,9 +178,9 @@ class RawQueryTests(TestCase):
order
"""
selects = (
('dob, last_name, first_name, id'),
('last_name, dob, first_name, id'),
('first_name, last_name, dob, id'),
("dob, last_name, first_name, id"),
("last_name, dob, first_name, id"),
("first_name, last_name, dob, id"),
)
for select in selects:
@ -162,7 +194,7 @@ class RawQueryTests(TestCase):
column names to specific model fields
"""
query = "SELECT first_name AS first, last_name AS last, dob, id FROM raw_query_author"
translations = {'first': 'first_name', 'last': 'last_name'}
translations = {"first": "first_name", "last": "last_name"}
authors = Author.objects.all()
self.assertSuccessfulRawQuery(Author, query, authors, translations=translations)
@ -190,14 +222,14 @@ class RawQueryTests(TestCase):
qset = Author.objects.raw(query)
self.assertEqual(len(qset), 2)
@skipUnlessDBFeature('supports_paramstyle_pyformat')
@skipUnlessDBFeature("supports_paramstyle_pyformat")
def test_pyformat_params(self):
"""
Test passing optional query parameters
"""
query = "SELECT * FROM raw_query_author WHERE first_name = %(first)s"
author = Author.objects.all()[2]
params = {'first': author.first_name}
params = {"first": author.first_name}
qset = Author.objects.raw(query, params=params)
results = list(qset)
self.assertProcessed(Author, results, [author])
@ -210,14 +242,26 @@ class RawQueryTests(TestCase):
Test representation of raw query with parameters
"""
query = "SELECT * FROM raw_query_author WHERE last_name = %(last)s"
qset = Author.objects.raw(query, {'last': 'foo'})
self.assertEqual(repr(qset), "<RawQuerySet: SELECT * FROM raw_query_author WHERE last_name = foo>")
self.assertEqual(repr(qset.query), "<RawQuery: SELECT * FROM raw_query_author WHERE last_name = foo>")
qset = Author.objects.raw(query, {"last": "foo"})
self.assertEqual(
repr(qset),
"<RawQuerySet: SELECT * FROM raw_query_author WHERE last_name = foo>",
)
self.assertEqual(
repr(qset.query),
"<RawQuery: SELECT * FROM raw_query_author WHERE last_name = foo>",
)
query = "SELECT * FROM raw_query_author WHERE last_name = %s"
qset = Author.objects.raw(query, {'foo'})
self.assertEqual(repr(qset), "<RawQuerySet: SELECT * FROM raw_query_author WHERE last_name = foo>")
self.assertEqual(repr(qset.query), "<RawQuery: SELECT * FROM raw_query_author WHERE last_name = foo>")
qset = Author.objects.raw(query, {"foo"})
self.assertEqual(
repr(qset),
"<RawQuerySet: SELECT * FROM raw_query_author WHERE last_name = foo>",
)
self.assertEqual(
repr(qset.query),
"<RawQuery: SELECT * FROM raw_query_author WHERE last_name = foo>",
)
def test_many_to_many(self):
"""
@ -230,7 +274,7 @@ class RawQueryTests(TestCase):
def test_extra_conversions(self):
"""Extra translations are ignored."""
query = "SELECT * FROM raw_query_author"
translations = {'something': 'else'}
translations = {"something": "else"}
authors = Author.objects.all()
self.assertSuccessfulRawQuery(Author, query, authors, translations=translations)
@ -243,7 +287,7 @@ class RawQueryTests(TestCase):
def test_missing_fields_without_PK(self):
query = "SELECT first_name, dob FROM raw_query_author"
msg = 'Raw query must include the primary key'
msg = "Raw query must include the primary key"
with self.assertRaisesMessage(FieldDoesNotExist, msg):
list(Author.objects.raw(query))
@ -255,10 +299,10 @@ class RawQueryTests(TestCase):
"GROUP BY a.id, a.first_name, a.last_name, a.dob ORDER BY a.id"
)
expected_annotations = (
('book_count', 3),
('book_count', 0),
('book_count', 1),
('book_count', 0),
("book_count", 3),
("book_count", 0),
("book_count", 1),
("book_count", 0),
)
authors = Author.objects.all()
self.assertSuccessfulRawQuery(Author, query, authors, expected_annotations)
@ -291,26 +335,32 @@ class RawQueryTests(TestCase):
# Indexing on RawQuerySets
query = "SELECT * FROM raw_query_author ORDER BY id ASC"
third_author = Author.objects.raw(query)[2]
self.assertEqual(third_author.first_name, 'Bob')
self.assertEqual(third_author.first_name, "Bob")
first_two = Author.objects.raw(query)[0:2]
self.assertEqual(len(first_two), 2)
with self.assertRaises(TypeError):
Author.objects.raw(query)['test']
Author.objects.raw(query)["test"]
def test_inheritance(self):
f = FriendlyAuthor.objects.create(first_name="Wesley", last_name="Chun", dob=date(1962, 10, 28))
query = "SELECT * FROM raw_query_friendlyauthor"
self.assertEqual(
[o.pk for o in FriendlyAuthor.objects.raw(query)], [f.pk]
f = FriendlyAuthor.objects.create(
first_name="Wesley", last_name="Chun", dob=date(1962, 10, 28)
)
query = "SELECT * FROM raw_query_friendlyauthor"
self.assertEqual([o.pk for o in FriendlyAuthor.objects.raw(query)], [f.pk])
def test_query_count(self):
self.assertNumQueries(1, list, Author.objects.raw("SELECT * FROM raw_query_author"))
self.assertNumQueries(
1, list, Author.objects.raw("SELECT * FROM raw_query_author")
)
def test_subquery_in_raw_sql(self):
list(Book.objects.raw('SELECT id FROM (SELECT * FROM raw_query_book WHERE paperback IS NOT NULL) sq'))
list(
Book.objects.raw(
"SELECT id FROM (SELECT * FROM raw_query_book WHERE paperback IS NOT NULL) sq"
)
)
def test_db_column_name_is_used_in_raw_query(self):
"""
@ -321,29 +371,42 @@ class RawQueryTests(TestCase):
same.
"""
b = BookFkAsPk.objects.create(book=self.b1)
self.assertEqual(list(BookFkAsPk.objects.raw('SELECT not_the_default FROM raw_query_bookfkaspk')), [b])
self.assertEqual(
list(
BookFkAsPk.objects.raw(
"SELECT not_the_default FROM raw_query_bookfkaspk"
)
),
[b],
)
def test_decimal_parameter(self):
c = Coffee.objects.create(brand='starbucks', price=20.5)
qs = Coffee.objects.raw("SELECT * FROM raw_query_coffee WHERE price >= %s", params=[Decimal(20)])
c = Coffee.objects.create(brand="starbucks", price=20.5)
qs = Coffee.objects.raw(
"SELECT * FROM raw_query_coffee WHERE price >= %s", params=[Decimal(20)]
)
self.assertEqual(list(qs), [c])
def test_result_caching(self):
with self.assertNumQueries(1):
books = Book.objects.raw('SELECT * FROM raw_query_book')
books = Book.objects.raw("SELECT * FROM raw_query_book")
list(books)
list(books)
def test_iterator(self):
with self.assertNumQueries(2):
books = Book.objects.raw('SELECT * FROM raw_query_book')
books = Book.objects.raw("SELECT * FROM raw_query_book")
list(books.iterator())
list(books.iterator())
def test_bool(self):
self.assertIs(bool(Book.objects.raw('SELECT * FROM raw_query_book')), True)
self.assertIs(bool(Book.objects.raw('SELECT * FROM raw_query_book WHERE id = 0')), False)
self.assertIs(bool(Book.objects.raw("SELECT * FROM raw_query_book")), True)
self.assertIs(
bool(Book.objects.raw("SELECT * FROM raw_query_book WHERE id = 0")), False
)
def test_len(self):
self.assertEqual(len(Book.objects.raw('SELECT * FROM raw_query_book')), 4)
self.assertEqual(len(Book.objects.raw('SELECT * FROM raw_query_book WHERE id = 0')), 0)
self.assertEqual(len(Book.objects.raw("SELECT * FROM raw_query_book")), 4)
self.assertEqual(
len(Book.objects.raw("SELECT * FROM raw_query_book WHERE id = 0")), 0
)