Debian Codegraph @

tests/composite_pk/test_aggregate.py

raw
1 from django.db.models import Count, Max, Q
2 from django.test import TestCase
3
4 from .models import Comment, Tenant, User
5
6
7 class CompositePKAggregateTests(TestCase):
8 @classmethod
9 def setUpTestData(cls):
10 cls.tenant_1 = Tenant.objects.create()
11 cls.tenant_2 = Tenant.objects.create()
12 cls.user_1 = User.objects.create(
13 tenant=cls.tenant_1,
14 id=1,
15 email="[email protected]",
16 )
17 cls.user_2 = User.objects.create(
18 tenant=cls.tenant_1,
19 id=2,
20 email="[email protected]",
21 )
22 cls.user_3 = User.objects.create(
23 tenant=cls.tenant_2,
24 id=3,
25 email="[email protected]",
26 )
27 cls.comment_1 = Comment.objects.create(id=1, user=cls.user_2, text="foo")
28 cls.comment_2 = Comment.objects.create(id=2, user=cls.user_1, text="bar")
29 cls.comment_3 = Comment.objects.create(id=3, user=cls.user_1, text="foobar")
30 cls.comment_4 = Comment.objects.create(id=4, user=cls.user_3, text="foobarbaz")
31 cls.comment_5 = Comment.objects.create(id=5, user=cls.user_3, text="barbaz")
32 cls.comment_6 = Comment.objects.create(id=6, user=cls.user_3, text="baz")
33
34 def test_users_annotated_with_comments_id_count(self):
35 user_1, user_2, user_3 = User.objects.annotate(Count("comments__id")).order_by(
36 "pk"
37 )
38
39 self.assertEqual(user_1, self.user_1)
40 self.assertEqual(user_1.comments__id__count, 2)
41 self.assertEqual(user_2, self.user_2)
42 self.assertEqual(user_2.comments__id__count, 1)
43 self.assertEqual(user_3, self.user_3)
44 self.assertEqual(user_3.comments__id__count, 3)
45
46 def test_users_annotated_with_aliased_comments_id_count(self):
47 user_1, user_2, user_3 = User.objects.annotate(
48 comments_count=Count("comments__id")
49 ).order_by("pk")
50
51 self.assertEqual(user_1, self.user_1)
52 self.assertEqual(user_1.comments_count, 2)
53 self.assertEqual(user_2, self.user_2)
54 self.assertEqual(user_2.comments_count, 1)
55 self.assertEqual(user_3, self.user_3)
56 self.assertEqual(user_3.comments_count, 3)
57
58 def test_users_annotated_with_comments_count(self):
59 user_1, user_2, user_3 = User.objects.annotate(Count("comments")).order_by("pk")
60
61 self.assertEqual(user_1, self.user_1)
62 self.assertEqual(user_1.comments__count, 2)
63 self.assertEqual(user_2, self.user_2)
64 self.assertEqual(user_2.comments__count, 1)
65 self.assertEqual(user_3, self.user_3)
66 self.assertEqual(user_3.comments__count, 3)
67
68 def test_users_annotated_with_comments_count_filter(self):
69 user_1, user_2, user_3 = User.objects.annotate(
70 comments__count=Count(
71 "comments", filter=Q(pk__in=[self.user_1.pk, self.user_2.pk])
72 )
73 ).order_by("pk")
74
75 self.assertEqual(user_1, self.user_1)
76 self.assertEqual(user_1.comments__count, 2)
77 self.assertEqual(user_2, self.user_2)
78 self.assertEqual(user_2.comments__count, 1)
79 self.assertEqual(user_3, self.user_3)
80 self.assertEqual(user_3.comments__count, 0)
81
82 def test_count_distinct_not_supported(self):
83 with self.assertRaisesMessage(
84 ValueError, "COUNT(DISTINCT) doesn't support composite primary keys"
85 ):
86 self.assertIsNone(
87 User.objects.annotate(comments__count=Count("comments", distinct=True))
88 )
89
90 def test_user_values_annotated_with_comments_id_count(self):
91 self.assertSequenceEqual(
92 User.objects.values("pk").annotate(Count("comments__id")).order_by("pk"),
93 (
94 {"pk": self.user_1.pk, "comments__id__count": 2},
95 {"pk": self.user_2.pk, "comments__id__count": 1},
96 {"pk": self.user_3.pk, "comments__id__count": 3},
97 ),
98 )
99
100 def test_user_values_annotated_with_filtered_comments_id_count(self):
101 self.assertSequenceEqual(
102 User.objects.values("pk")
103 .annotate(
104 comments_count=Count(
105 "comments__id",
106 filter=Q(comments__text__icontains="foo"),
107 )
108 )
109 .order_by("pk"),
110 (
111 {"pk": self.user_1.pk, "comments_count": 1},
112 {"pk": self.user_2.pk, "comments_count": 1},
113 {"pk": self.user_3.pk, "comments_count": 1},
114 ),
115 )
116
117 def test_filter_and_count_users_by_comments_fields(self):
118 users = User.objects.filter(comments__id__gt=2).order_by("pk")
119 self.assertEqual(users.count(), 4)
120 self.assertSequenceEqual(
121 users, (self.user_1, self.user_3, self.user_3, self.user_3)
122 )
123
124 users = User.objects.filter(comments__text__icontains="foo").order_by("pk")
125 self.assertEqual(users.count(), 3)
126 self.assertSequenceEqual(users, (self.user_1, self.user_2, self.user_3))
127
128 users = User.objects.filter(comments__text__icontains="baz").order_by("pk")
129 self.assertEqual(users.count(), 3)
130 self.assertSequenceEqual(users, (self.user_3, self.user_3, self.user_3))
131
132 def test_order_by_comments_id_count(self):
133 self.assertSequenceEqual(
134 User.objects.annotate(comments_count=Count("comments__id")).order_by(
135 "-comments_count"
136 ),
137 (self.user_3, self.user_1, self.user_2),
138 )
139
140 def test_max_pk(self):
141 msg = "Max expression does not support composite primary keys."
142 with self.assertRaisesMessage(ValueError, msg):
143 Comment.objects.aggregate(Max("pk"))
144
145 def test_first_from_unordered_queryset_aggregation_pk_selected(self):
146 self.assertEqual(
147 Comment.objects.values("pk").annotate(max=Max("id")).first(),
148 {"pk": (self.comment_1.tenant_id, 1), "max": 1},
149 )
150
151 def test_first_from_unordered_queryset_aggregation_pk_selected_separately(self):
152 self.assertEqual(
153 Comment.objects.values("tenant", "id").annotate(max=Max("id")).first(),
154 {"tenant": self.comment_1.tenant_id, "id": 1, "max": 1},
155 )
156
157 def test_first_from_unordered_queryset_aggregation_pk_incomplete(self):
158 msg = (
159 "Cannot use QuerySet.first() on an unordered queryset performing "
160 "aggregation. Add an ordering with order_by()."
161 )
162 with self.assertRaisesMessage(TypeError, msg):
163 Comment.objects.values("tenant").annotate(max=Max("id")).first()