| 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) |