Debian Codegraph @

tests/composite_pk/tests.py

raw
1 import json
2 import unittest
3 from uuid import UUID
4
5 try:
6 import yaml # NOQA
7
8 HAS_YAML = True
9 except ImportError:
10 HAS_YAML = False
11
12 from django import forms
13 from django.core import serializers
14 from django.core.exceptions import FieldError
15 from django.db import IntegrityError, connection
16 from django.db.models import CompositePrimaryKey
17 from django.forms import modelform_factory
18 from django.test import TestCase
19
20 from .models import Comment, Post, Tenant, TimeStamped, User
21
22
23 class CommentForm(forms.ModelForm):
24 class Meta:
25 model = Comment
26 fields = "__all__"
27
28
29 class CompositePKTests(TestCase):
30 maxDiff = None
31
32 @classmethod
33 def setUpTestData(cls):
34 cls.tenant = Tenant.objects.create()
35 cls.user = User.objects.create(
36 tenant=cls.tenant,
37 id=1,
38 email="[email protected]",
39 )
40 cls.comment = Comment.objects.create(tenant=cls.tenant, id=1, user=cls.user)
41
42 @staticmethod
43 def get_primary_key_columns(table):
44 with connection.cursor() as cursor:
45 return connection.introspection.get_primary_key_columns(cursor, table)
46
47 def test_pk_updated_if_field_updated(self):
48 user = User.objects.get(pk=self.user.pk)
49 self.assertEqual(user.pk, (self.tenant.id, self.user.id))
50 self.assertIs(user._is_pk_set(), True)
51 user.tenant_id = 9831
52 self.assertEqual(user.pk, (9831, self.user.id))
53 self.assertIs(user._is_pk_set(), True)
54 user.id = 4321
55 self.assertEqual(user.pk, (9831, 4321))
56 self.assertIs(user._is_pk_set(), True)
57 user.pk = (9132, 3521)
58 self.assertEqual(user.tenant_id, 9132)
59 self.assertEqual(user.id, 3521)
60 self.assertIs(user._is_pk_set(), True)
61 user.id = None
62 self.assertEqual(user.pk, (9132, None))
63 self.assertEqual(user.tenant_id, 9132)
64 self.assertIsNone(user.id)
65 self.assertIs(user._is_pk_set(), False)
66
67 def test_hash(self):
68 self.assertEqual(hash(User(pk=(1, 2))), hash((1, 2)))
69 self.assertEqual(hash(User(tenant_id=2, id=3)), hash((2, 3)))
70 msg = "Model instances without primary key value are unhashable"
71
72 with self.assertRaisesMessage(TypeError, msg):
73 hash(User())
74 with self.assertRaisesMessage(TypeError, msg):
75 hash(User(tenant_id=1))
76 with self.assertRaisesMessage(TypeError, msg):
77 hash(User(id=1))
78
79 def test_pk_must_be_list_or_tuple(self):
80 user = User.objects.get(pk=self.user.pk)
81 test_cases = [
82 "foo",
83 1000,
84 3.14,
85 True,
86 False,
87 ]
88
89 for pk in test_cases:
90 with self.assertRaisesMessage(
91 ValueError, "'pk' must be a list or a tuple."
92 ):
93 user.pk = pk
94
95 def test_pk_must_have_2_elements(self):
96 user = User.objects.get(pk=self.user.pk)
97 test_cases = [
98 (),
99 [],
100 (1000,),
101 [1000],
102 (1, 2, 3),
103 [1, 2, 3],
104 ]
105
106 for pk in test_cases:
107 with self.assertRaisesMessage(ValueError, "'pk' must have 2 elements."):
108 user.pk = pk
109
110 def test_composite_pk_in_fields(self):
111 user_fields = {f.name for f in User._meta.get_fields()}
112 self.assertTrue({"pk", "tenant", "id"}.issubset(user_fields))
113
114 comment_fields = {f.name for f in Comment._meta.get_fields()}
115 self.assertTrue({"pk", "tenant", "id"}.issubset(comment_fields))
116
117 def test_pk_field(self):
118 pk = User._meta.get_field("pk")
119 self.assertIsInstance(pk, CompositePrimaryKey)
120 self.assertIs(User._meta.pk, pk)
121
122 def test_error_on_user_pk_conflict(self):
123 with self.assertRaises(IntegrityError):
124 User.objects.create(tenant=self.tenant, id=self.user.id)
125
126 def test_error_on_comment_pk_conflict(self):
127 with self.assertRaises(IntegrityError):
128 Comment.objects.create(tenant=self.tenant, id=self.comment.id, user_id=1)
129
130 def test_get_primary_key_columns(self):
131 self.assertEqual(
132 self.get_primary_key_columns(User._meta.db_table),
133 ["tenant_id", "id"],
134 )
135 self.assertEqual(
136 self.get_primary_key_columns(Comment._meta.db_table),
137 ["tenant_id", "comment_id"],
138 )
139
140 def test_in_bulk(self):
141 """
142 Test the .in_bulk() method of composite_pk models.
143 """
144 result = Comment.objects.in_bulk()
145 self.assertEqual(result, {self.comment.pk: self.comment})
146
147 result = Comment.objects.in_bulk([self.comment.pk])
148 self.assertEqual(result, {self.comment.pk: self.comment})
149
150 @unittest.mock.patch.object(
151 type(connection.features), "max_query_params", new_callable=lambda: 10
152 )
153 def test_in_bulk_batching(self, mocked_max_query_params):
154 Comment.objects.all().delete()
155 num_requiring_batching = (connection.features.max_query_params // 2) + 1
156 comments = [
157 Comment(id=i, tenant=self.tenant, user=self.user)
158 for i in range(1, num_requiring_batching + 1)
159 ]
160 Comment.objects.bulk_create(comments)
161 id_list = list(Comment.objects.values_list("pk", flat=True))
162 with self.assertNumQueries(2):
163 comment_dict = Comment.objects.in_bulk(id_list=id_list)
164 self.assertQuerySetEqual(comment_dict, id_list)
165
166 def test_iterator(self):
167 """
168 Test the .iterator() method of composite_pk models.
169 """
170 result = list(Comment.objects.iterator())
171 self.assertEqual(result, [self.comment])
172
173 def test_query(self):
174 users = User.objects.values_list("pk").order_by("pk")
175 self.assertNotIn('AS "pk"', str(users.query))
176
177 def test_only(self):
178 users = User.objects.only("pk")
179 self.assertSequenceEqual(users, (self.user,))
180 user = users[0]
181
182 with self.assertNumQueries(0):
183 self.assertEqual(user.pk, (self.user.tenant_id, self.user.id))
184 self.assertEqual(user.tenant_id, self.user.tenant_id)
185 self.assertEqual(user.id, self.user.id)
186 with self.assertNumQueries(1):
187 self.assertEqual(user.email, self.user.email)
188
189 def test_select_related(self):
190 Comment.objects.create(tenant=self.tenant, id=2)
191 with self.assertNumQueries(1):
192 comments = list(Comment.objects.select_related("user").order_by("pk"))
193 self.assertEqual(len(comments), 2)
194 self.assertEqual(comments[0].user, self.user)
195 self.assertIsNone(comments[1].user)
196
197 def test_model_forms(self):
198 fields = ["tenant", "id", "user_id", "text", "integer"]
199 self.assertEqual(list(CommentForm.base_fields), fields)
200
201 form = modelform_factory(Comment, fields="__all__")
202 self.assertEqual(list(form().fields), fields)
203
204 with self.assertRaisesMessage(
205 FieldError, "Unknown field(s) (pk) specified for Comment"
206 ):
207 self.assertIsNone(modelform_factory(Comment, fields=["pk"]))
208
209
210 class CompositePKFixturesTests(TestCase):
211 fixtures = ["tenant"]
212
213 def test_objects(self):
214 tenant_1, tenant_2, tenant_3 = Tenant.objects.order_by("pk")
215 self.assertEqual(tenant_1.id, 1)
216 self.assertEqual(tenant_1.name, "Tenant 1")
217 self.assertEqual(tenant_2.id, 2)
218 self.assertEqual(tenant_2.name, "Tenant 2")
219 self.assertEqual(tenant_3.id, 3)
220 self.assertEqual(tenant_3.name, "Tenant 3")
221
222 user_1, user_2, user_3, user_4 = User.objects.order_by("pk")
223 self.assertEqual(user_1.id, 1)
224 self.assertEqual(user_1.tenant_id, 1)
225 self.assertEqual(user_1.pk, (user_1.tenant_id, user_1.id))
226 self.assertEqual(user_1.email, "[email protected]")
227 self.assertEqual(user_2.id, 2)
228 self.assertEqual(user_2.tenant_id, 1)
229 self.assertEqual(user_2.pk, (user_2.tenant_id, user_2.id))
230 self.assertEqual(user_2.email, "[email protected]")
231 self.assertEqual(user_3.id, 3)
232 self.assertEqual(user_3.tenant_id, 2)
233 self.assertEqual(user_3.pk, (user_3.tenant_id, user_3.id))
234 self.assertEqual(user_3.email, "[email protected]")
235 self.assertEqual(user_4.id, 4)
236 self.assertEqual(user_4.tenant_id, 2)
237 self.assertEqual(user_4.pk, (user_4.tenant_id, user_4.id))
238 self.assertEqual(user_4.email, "[email protected]")
239
240 post_1, post_2 = Post.objects.order_by("pk")
241 self.assertEqual(post_1.id, UUID("11111111-1111-1111-1111-111111111111"))
242 self.assertEqual(post_1.tenant_id, 2)
243 self.assertEqual(post_1.pk, (post_1.tenant_id, post_1.id))
244 self.assertEqual(post_2.id, UUID("ffffffff-ffff-ffff-ffff-ffffffffffff"))
245 self.assertEqual(post_2.tenant_id, 2)
246 self.assertEqual(post_2.pk, (post_2.tenant_id, post_2.id))
247
248 def assert_deserializer(self, format, users, serialized_users):
249 deserialized_user = list(serializers.deserialize(format, serialized_users))[0]
250 self.assertEqual(deserialized_user.object.email, users[0].email)
251 self.assertEqual(deserialized_user.object.id, users[0].id)
252 self.assertEqual(deserialized_user.object.tenant, users[0].tenant)
253 self.assertEqual(deserialized_user.object.pk, users[0].pk)
254
255 def test_serialize_user_json(self):
256 users = User.objects.filter(pk=(1, 1))
257 result = serializers.serialize("json", users)
258 self.assertEqual(
259 json.loads(result),
260 [
261 {
262 "model": "composite_pk.user",
263 "pk": [1, 1],
264 "fields": {
265 "email": "[email protected]",
266 "id": 1,
267 "tenant": 1,
268 },
269 }
270 ],
271 )
272 self.assert_deserializer(format="json", users=users, serialized_users=result)
273
274 def test_serialize_user_jsonl(self):
275 users = User.objects.filter(pk=(1, 2))
276 result = serializers.serialize("jsonl", users)
277 self.assertEqual(
278 json.loads(result),
279 {
280 "model": "composite_pk.user",
281 "pk": [1, 2],
282 "fields": {
283 "email": "[email protected]",
284 "id": 2,
285 "tenant": 1,
286 },
287 },
288 )
289 self.assert_deserializer(format="jsonl", users=users, serialized_users=result)
290
291 @unittest.skipUnless(HAS_YAML, "No yaml library detected")
292 def test_serialize_user_yaml(self):
293 users = User.objects.filter(pk=(2, 3))
294 result = serializers.serialize("yaml", users)
295 self.assertEqual(
296 yaml.safe_load(result),
297 [
298 {
299 "model": "composite_pk.user",
300 "pk": [2, 3],
301 "fields": {
302 "email": "[email protected]",
303 "id": 3,
304 "tenant": 2,
305 },
306 },
307 ],
308 )
309 self.assert_deserializer(format="yaml", users=users, serialized_users=result)
310
311 def test_serialize_user_python(self):
312 users = User.objects.filter(pk=(2, 4))
313 result = serializers.serialize("python", users)
314 self.assertEqual(
315 result,
316 [
317 {
318 "model": "composite_pk.user",
319 "pk": [2, 4],
320 "fields": {
321 "email": "[email protected]",
322 "id": 4,
323 "tenant": 2,
324 },
325 },
326 ],
327 )
328 self.assert_deserializer(format="python", users=users, serialized_users=result)
329
330 def test_serialize_user_xml(self):
331 users = User.objects.filter(pk=(1, 1))
332 result = serializers.serialize("xml", users)
333 self.assertIn('<object model="composite_pk.user" pk=\'["1", "1"]\'>', result)
334 self.assert_deserializer(format="xml", users=users, serialized_users=result)
335
336 def test_serialize_post_uuid(self):
337 posts = Post.objects.filter(pk=(2, "11111111-1111-1111-1111-111111111111"))
338 result = serializers.serialize("json", posts)
339 self.assertEqual(
340 json.loads(result),
341 [
342 {
343 "model": "composite_pk.post",
344 "pk": [2, "11111111-1111-1111-1111-111111111111"],
345 "fields": {
346 "id": "11111111-1111-1111-1111-111111111111",
347 "tenant": 2,
348 },
349 },
350 ],
351 )
352
353 def test_serialize_datetime(self):
354 result = serializers.serialize("json", TimeStamped.objects.all())
355 self.assertEqual(
356 json.loads(result),
357 [
358 {
359 "model": "composite_pk.timestamped",
360 "pk": [1, "2022-01-12T05:55:14.956"],
361 "fields": {
362 "id": 1,
363 "created": "2022-01-12T05:55:14.956",
364 "text": "",
365 },
366 },
367 ],
368 )
369
370 def test_invalid_pk_extra_field(self):
371 json = (
372 '[{"fields": {"email": "[email protected]", "id": 1, "tenant": 1}, '
373 '"pk": [1, 1, "extra"], "model": "composite_pk.user"}]'
374 )
375 with self.assertRaises(serializers.base.DeserializationError):
376 next(serializers.deserialize("json", json))