Debian Codegraph @

tests/known_related_objects/tests.py

raw
1 from django.db.models import FilteredRelation
2 from django.test import TestCase
3
4 from .models import Organiser, Pool, PoolStyle, Tournament
5
6
7 class ExistingRelatedInstancesTests(TestCase):
8 @classmethod
9 def setUpTestData(cls):
10 cls.t1 = Tournament.objects.create(name="Tourney 1")
11 cls.t2 = Tournament.objects.create(name="Tourney 2")
12 cls.o1 = Organiser.objects.create(name="Organiser 1")
13 cls.p1 = Pool.objects.create(
14 name="T1 Pool 1", tournament=cls.t1, organiser=cls.o1
15 )
16 cls.p2 = Pool.objects.create(
17 name="T1 Pool 2", tournament=cls.t1, organiser=cls.o1
18 )
19 cls.p3 = Pool.objects.create(
20 name="T2 Pool 1", tournament=cls.t2, organiser=cls.o1
21 )
22 cls.p4 = Pool.objects.create(
23 name="T2 Pool 2", tournament=cls.t2, organiser=cls.o1
24 )
25 cls.ps1 = PoolStyle.objects.create(name="T1 Pool 2 Style", pool=cls.p2)
26 cls.ps2 = PoolStyle.objects.create(name="T2 Pool 1 Style", pool=cls.p3)
27 cls.ps3 = PoolStyle.objects.create(
28 name="T1 Pool 1/3 Style", pool=cls.p1, another_pool=cls.p3
29 )
30
31 def test_foreign_key(self):
32 with self.assertNumQueries(2):
33 tournament = Tournament.objects.get(pk=self.t1.pk)
34 pool = tournament.pool_set.all()[0]
35 self.assertIs(tournament, pool.tournament)
36
37 def test_foreign_key_prefetch_related(self):
38 with self.assertNumQueries(2):
39 tournament = Tournament.objects.prefetch_related("pool_set").get(
40 pk=self.t1.pk
41 )
42 pool = tournament.pool_set.all()[0]
43 self.assertIs(tournament, pool.tournament)
44
45 def test_foreign_key_multiple_prefetch(self):
46 with self.assertNumQueries(2):
47 tournaments = list(
48 Tournament.objects.prefetch_related("pool_set").order_by("pk")
49 )
50 pool1 = tournaments[0].pool_set.all()[0]
51 self.assertIs(tournaments[0], pool1.tournament)
52 pool2 = tournaments[1].pool_set.all()[0]
53 self.assertIs(tournaments[1], pool2.tournament)
54
55 def test_queryset_or(self):
56 tournament_1 = self.t1
57 tournament_2 = self.t2
58 with self.assertNumQueries(1):
59 pools = tournament_1.pool_set.all() | tournament_2.pool_set.all()
60 related_objects = {pool.tournament for pool in pools}
61 self.assertEqual(related_objects, {tournament_1, tournament_2})
62
63 def test_queryset_or_different_cached_items(self):
64 tournament = self.t1
65 organiser = self.o1
66 with self.assertNumQueries(1):
67 pools = tournament.pool_set.all() | organiser.pool_set.all()
68 first = pools.filter(pk=self.p1.pk)[0]
69 self.assertIs(first.tournament, tournament)
70 self.assertIs(first.organiser, organiser)
71
72 def test_queryset_or_only_one_with_precache(self):
73 tournament_1 = self.t1
74 tournament_2 = self.t2
75 # 2 queries here as pool 3 has tournament 2, which is not cached
76 with self.assertNumQueries(2):
77 pools = tournament_1.pool_set.all() | Pool.objects.filter(pk=self.p3.pk)
78 related_objects = {pool.tournament for pool in pools}
79 self.assertEqual(related_objects, {tournament_1, tournament_2})
80 # and the other direction
81 with self.assertNumQueries(2):
82 pools = Pool.objects.filter(pk=self.p3.pk) | tournament_1.pool_set.all()
83 related_objects = {pool.tournament for pool in pools}
84 self.assertEqual(related_objects, {tournament_1, tournament_2})
85
86 def test_queryset_and(self):
87 tournament = self.t1
88 organiser = self.o1
89 with self.assertNumQueries(1):
90 pools = tournament.pool_set.all() & organiser.pool_set.all()
91 first = pools.filter(pk=self.p1.pk)[0]
92 self.assertIs(first.tournament, tournament)
93 self.assertIs(first.organiser, organiser)
94
95 def test_one_to_one(self):
96 with self.assertNumQueries(2):
97 style = PoolStyle.objects.get(pk=self.ps1.pk)
98 pool = style.pool
99 self.assertIs(style, pool.poolstyle)
100
101 def test_one_to_one_select_related(self):
102 with self.assertNumQueries(1):
103 style = PoolStyle.objects.select_related("pool").get(pk=self.ps1.pk)
104 pool = style.pool
105 self.assertIs(style, pool.poolstyle)
106
107 def test_one_to_one_multi_select_related(self):
108 with self.assertNumQueries(1):
109 poolstyles = list(PoolStyle.objects.select_related("pool").order_by("pk"))
110 self.assertIs(poolstyles[0], poolstyles[0].pool.poolstyle)
111 self.assertIs(poolstyles[1], poolstyles[1].pool.poolstyle)
112
113 def test_one_to_one_prefetch_related(self):
114 with self.assertNumQueries(2):
115 style = PoolStyle.objects.prefetch_related("pool").get(pk=self.ps1.pk)
116 pool = style.pool
117 self.assertIs(style, pool.poolstyle)
118
119 def test_one_to_one_multi_prefetch_related(self):
120 with self.assertNumQueries(2):
121 poolstyles = list(PoolStyle.objects.prefetch_related("pool").order_by("pk"))
122 self.assertIs(poolstyles[0], poolstyles[0].pool.poolstyle)
123 self.assertIs(poolstyles[1], poolstyles[1].pool.poolstyle)
124
125 def test_reverse_one_to_one(self):
126 with self.assertNumQueries(2):
127 pool = Pool.objects.get(pk=self.p2.pk)
128 style = pool.poolstyle
129 self.assertIs(pool, style.pool)
130
131 def test_reverse_one_to_one_select_related(self):
132 with self.assertNumQueries(1):
133 pool = Pool.objects.select_related("poolstyle").get(pk=self.p2.pk)
134 style = pool.poolstyle
135 self.assertIs(pool, style.pool)
136
137 def test_reverse_one_to_one_prefetch_related(self):
138 with self.assertNumQueries(2):
139 pool = Pool.objects.prefetch_related("poolstyle").get(pk=self.p2.pk)
140 style = pool.poolstyle
141 self.assertIs(pool, style.pool)
142
143 def test_reverse_one_to_one_multi_select_related(self):
144 with self.assertNumQueries(1):
145 pools = list(Pool.objects.select_related("poolstyle").order_by("pk"))
146 self.assertIs(pools[1], pools[1].poolstyle.pool)
147 self.assertIs(pools[2], pools[2].poolstyle.pool)
148
149 def test_reverse_one_to_one_multi_prefetch_related(self):
150 with self.assertNumQueries(2):
151 pools = list(Pool.objects.prefetch_related("poolstyle").order_by("pk"))
152 self.assertIs(pools[1], pools[1].poolstyle.pool)
153 self.assertIs(pools[2], pools[2].poolstyle.pool)
154
155 def test_reverse_fk_select_related_multiple(self):
156 with self.assertNumQueries(1):
157 ps = list(
158 PoolStyle.objects.annotate(
159 pool_1=FilteredRelation("pool"),
160 pool_2=FilteredRelation("another_pool"),
161 )
162 .select_related("pool_1", "pool_2")
163 .order_by("-pk")
164 )
165 self.assertIs(ps[0], ps[0].pool_1.poolstyle)
166 self.assertIs(ps[0], ps[0].pool_2.another_style)
167
168 def test_multilevel_reverse_fk_cyclic_select_related(self):
169 with self.assertNumQueries(3):
170 p = list(
171 PoolStyle.objects.annotate(
172 tournament_pool=FilteredRelation("pool__tournament__pool"),
173 ).select_related("tournament_pool", "tournament_pool__tournament")
174 )
175 self.assertEqual(p[0].tournament_pool.tournament, p[0].pool.tournament)
176
177 def test_multilevel_reverse_fk_select_related(self):
178 with self.assertNumQueries(2):
179 p = list(
180 Tournament.objects.filter(id=self.t2.id)
181 .annotate(
182 style=FilteredRelation("pool__another_style"),
183 )
184 .select_related("style")
185 )
186 self.assertEqual(p[0].style.another_pool, self.p3)