Debian Codegraph @

tests/select_related/tests.py

raw
1 from django.core.exceptions import FieldError
2 from django.test import SimpleTestCase, TestCase
3
4 from .models import (
5 Bookmark,
6 Domain,
7 Family,
8 Genus,
9 HybridSpecies,
10 Kingdom,
11 Klass,
12 Order,
13 Phylum,
14 Pizza,
15 Species,
16 TaggedItem,
17 )
18
19
20 class SelectRelatedTests(TestCase):
21 @classmethod
22 def create_tree(cls, stringtree):
23 """
24 Helper to create a complete tree.
25 """
26 names = stringtree.split()
27 models = [Domain, Kingdom, Phylum, Klass, Order, Family, Genus, Species]
28 assert len(names) == len(models), (names, models)
29
30 parent = None
31 for name, model in zip(names, models):
32 try:
33 obj = model.objects.get(name=name)
34 except model.DoesNotExist:
35 obj = model(name=name)
36 if parent:
37 setattr(obj, parent.__class__.__name__.lower(), parent)
38 obj.save()
39 parent = obj
40
41 @classmethod
42 def setUpTestData(cls):
43 cls.create_tree(
44 "Eukaryota Animalia Anthropoda Insecta Diptera Drosophilidae Drosophila "
45 "melanogaster"
46 )
47 cls.create_tree(
48 "Eukaryota Animalia Chordata Mammalia Primates Hominidae Homo sapiens"
49 )
50 cls.create_tree(
51 "Eukaryota Plantae Magnoliophyta Magnoliopsida Fabales Fabaceae Pisum "
52 "sativum"
53 )
54 cls.create_tree(
55 "Eukaryota Fungi Basidiomycota Homobasidiomycatae Agaricales Amanitacae "
56 "Amanita muscaria"
57 )
58
59 def test_access_fks_without_select_related(self):
60 """
61 Normally, accessing FKs doesn't fill in related objects
62 """
63 with self.assertNumQueries(8):
64 fly = Species.objects.get(name="melanogaster")
65 domain = fly.genus.family.order.klass.phylum.kingdom.domain
66 self.assertEqual(domain.name, "Eukaryota")
67
68 def test_access_fks_with_select_related(self):
69 """
70 A select_related() call will fill in those related objects without any
71 extra queries
72 """
73 with self.assertNumQueries(1):
74 person = Species.objects.select_related(
75 "genus__family__order__klass__phylum__kingdom__domain"
76 ).get(name="sapiens")
77 domain = person.genus.family.order.klass.phylum.kingdom.domain
78 self.assertEqual(domain.name, "Eukaryota")
79
80 def test_list_without_select_related(self):
81 with self.assertNumQueries(9):
82 world = Species.objects.all()
83 families = [o.genus.family.name for o in world]
84 self.assertEqual(
85 sorted(families),
86 [
87 "Amanitacae",
88 "Drosophilidae",
89 "Fabaceae",
90 "Hominidae",
91 ],
92 )
93
94 def test_list_with_select_related(self):
95 """select_related() applies to entire lists, not just items."""
96 with self.assertNumQueries(1):
97 world = Species.objects.select_related()
98 families = [o.genus.family.name for o in world]
99 self.assertEqual(
100 sorted(families),
101 [
102 "Amanitacae",
103 "Drosophilidae",
104 "Fabaceae",
105 "Hominidae",
106 ],
107 )
108
109 def test_list_with_depth(self):
110 """
111 Passing a relationship field lookup specifier to select_related() will
112 stop the descent at a particular level. This can be used on lists as
113 well.
114 """
115 with self.assertNumQueries(5):
116 world = Species.objects.select_related("genus__family")
117 orders = [o.genus.family.order.name for o in world]
118 self.assertEqual(
119 sorted(orders), ["Agaricales", "Diptera", "Fabales", "Primates"]
120 )
121
122 def test_select_related_with_extra(self):
123 s = (
124 Species.objects.all()
125 .select_related()
126 .extra(select={"a": "select_related_species.id + 10"})[0]
127 )
128 self.assertEqual(s.id + 10, s.a)
129
130 def test_certain_fields(self):
131 """
132 The optional fields passed to select_related() control which related
133 models we pull in. This allows for smaller queries.
134
135 In this case, we explicitly say to select the 'genus' and
136 'genus.family' models, leading to the same number of queries as before.
137 """
138 with self.assertNumQueries(1):
139 world = Species.objects.select_related("genus__family")
140 families = [o.genus.family.name for o in world]
141 self.assertEqual(
142 sorted(families),
143 ["Amanitacae", "Drosophilidae", "Fabaceae", "Hominidae"],
144 )
145
146 def test_more_certain_fields(self):
147 """
148 In this case, we explicitly say to select the 'genus' and
149 'genus.family' models, leading to the same number of queries as before.
150 """
151 with self.assertNumQueries(2):
152 world = Species.objects.filter(genus__name="Amanita").select_related(
153 "genus__family"
154 )
155 orders = [o.genus.family.order.name for o in world]
156 self.assertEqual(orders, ["Agaricales"])
157
158 def test_field_traversal(self):
159 with self.assertNumQueries(1):
160 s = (
161 Species.objects.all()
162 .select_related("genus__family__order")
163 .order_by("id")[0:1]
164 .get()
165 .genus.family.order.name
166 )
167 self.assertEqual(s, "Diptera")
168
169 def test_none_clears_list(self):
170 queryset = Species.objects.select_related("genus").select_related(None)
171 self.assertIs(queryset.query.select_related, False)
172
173 def test_chaining(self):
174 parent_1, parent_2 = Species.objects.all()[:2]
175 HybridSpecies.objects.create(
176 name="hybrid", parent_1=parent_1, parent_2=parent_2
177 )
178 queryset = HybridSpecies.objects.select_related("parent_1").select_related(
179 "parent_2"
180 )
181 with self.assertNumQueries(1):
182 obj = queryset[0]
183 self.assertEqual(obj.parent_1, parent_1)
184 self.assertEqual(obj.parent_2, parent_2)
185
186 def test_reverse_relation_caching(self):
187 species = (
188 Species.objects.select_related("genus").filter(name="melanogaster").first()
189 )
190 with self.assertNumQueries(0):
191 self.assertEqual(species.genus.name, "Drosophila")
192 # The species_set reverse relation isn't cached.
193 self.assertEqual(species.genus._state.fields_cache, {})
194 with self.assertNumQueries(1):
195 self.assertEqual(species.genus.species_set.first().name, "melanogaster")
196
197 def test_select_related_after_values(self):
198 """
199 Running select_related() after calling values() raises a TypeError
200 """
201 message = "Cannot call select_related() after .values() or .values_list()"
202 with self.assertRaisesMessage(TypeError, message):
203 list(Species.objects.values("name").select_related("genus"))
204
205 def test_select_related_after_values_list(self):
206 """
207 Running select_related() after calling values_list() raises a TypeError
208 """
209 message = "Cannot call select_related() after .values() or .values_list()"
210 with self.assertRaisesMessage(TypeError, message):
211 list(Species.objects.values_list("name").select_related("genus"))
212
213
214 class SelectRelatedValidationTests(SimpleTestCase):
215 """
216 select_related() should thrown an error on fields that do not exist and
217 non-relational fields.
218 """
219
220 non_relational_error = (
221 "Non-relational field given in select_related: '%s'. Choices are: %s"
222 )
223 invalid_error = (
224 "Invalid field name(s) given in select_related: '%s'. Choices are: %s"
225 )
226
227 def test_non_relational_field(self):
228 with self.assertRaisesMessage(
229 FieldError, self.non_relational_error % ("name", "genus")
230 ):
231 list(Species.objects.select_related("name__some_field"))
232
233 with self.assertRaisesMessage(
234 FieldError, self.non_relational_error % ("name", "genus")
235 ):
236 list(Species.objects.select_related("name"))
237
238 with self.assertRaisesMessage(
239 FieldError, self.non_relational_error % ("name", "(none)")
240 ):
241 list(Domain.objects.select_related("name"))
242
243 def test_non_relational_field_nested(self):
244 with self.assertRaisesMessage(
245 FieldError, self.non_relational_error % ("name", "family")
246 ):
247 list(Species.objects.select_related("genus__name"))
248
249 def test_many_to_many_field(self):
250 with self.assertRaisesMessage(
251 FieldError, self.invalid_error % ("toppings", "(none)")
252 ):
253 list(Pizza.objects.select_related("toppings"))
254
255 def test_reverse_relational_field(self):
256 with self.assertRaisesMessage(
257 FieldError, self.invalid_error % ("child_1", "genus")
258 ):
259 list(Species.objects.select_related("child_1"))
260
261 def test_invalid_field(self):
262 with self.assertRaisesMessage(
263 FieldError, self.invalid_error % ("invalid_field", "genus")
264 ):
265 list(Species.objects.select_related("invalid_field"))
266
267 with self.assertRaisesMessage(
268 FieldError, self.invalid_error % ("related_invalid_field", "family")
269 ):
270 list(Species.objects.select_related("genus__related_invalid_field"))
271
272 with self.assertRaisesMessage(
273 FieldError, self.invalid_error % ("invalid_field", "(none)")
274 ):
275 list(Domain.objects.select_related("invalid_field"))
276
277 def test_generic_relations(self):
278 with self.assertRaisesMessage(FieldError, self.invalid_error % ("tags", "")):
279 list(Bookmark.objects.select_related("tags"))
280
281 with self.assertRaisesMessage(
282 FieldError, self.invalid_error % ("content_object", "content_type")
283 ):
284 list(TaggedItem.objects.select_related("content_object"))