Debian Codegraph @

tests/serializers/tests.py

raw
1 from datetime import datetime
2 from functools import partialmethod
3 from io import StringIO
4 from unittest import mock, skipIf
5
6 from django.core import serializers
7 from django.core.serializers import SerializerDoesNotExist
8 from django.core.serializers.base import ProgressBar
9 from django.db import connection, transaction
10 from django.db.models import Prefetch
11 from django.http import HttpResponse
12 from django.test import SimpleTestCase, override_settings, skipUnlessDBFeature
13 from django.test.utils import Approximate
14
15 from .models import (
16 Actor,
17 Article,
18 Author,
19 AuthorProfile,
20 BaseModel,
21 Category,
22 CategoryMetaData,
23 Child,
24 ComplexModel,
25 Movie,
26 Player,
27 ProxyBaseModel,
28 ProxyProxyBaseModel,
29 Score,
30 Team,
31 )
32
33
34 @override_settings(
35 SERIALIZATION_MODULES={
36 "json2": "django.core.serializers.json",
37 }
38 )
39 class SerializerRegistrationTests(SimpleTestCase):
40 def setUp(self):
41 self.old_serializers = serializers._serializers
42 serializers._serializers = {}
43
44 def tearDown(self):
45 serializers._serializers = self.old_serializers
46
47 def test_register(self):
48 "Registering a new serializer populates the full registry. Refs #14823"
49 serializers.register_serializer("json3", "django.core.serializers.json")
50
51 public_formats = serializers.get_public_serializer_formats()
52 self.assertIn("json3", public_formats)
53 self.assertIn("json2", public_formats)
54 self.assertIn("xml", public_formats)
55
56 def test_unregister(self):
57 """
58 Unregistering a serializer doesn't cause the registry to be
59 repopulated.
60 """
61 serializers.unregister_serializer("xml")
62 serializers.register_serializer("json3", "django.core.serializers.json")
63
64 public_formats = serializers.get_public_serializer_formats()
65
66 self.assertNotIn("xml", public_formats)
67 self.assertIn("json3", public_formats)
68
69 def test_unregister_unknown_serializer(self):
70 with self.assertRaises(SerializerDoesNotExist):
71 serializers.unregister_serializer("nonsense")
72
73 def test_builtin_serializers(self):
74 "Requesting a list of serializer formats populates the registry"
75 all_formats = set(serializers.get_serializer_formats())
76 public_formats = set(serializers.get_public_serializer_formats())
77
78 self.assertIn("xml", all_formats)
79 self.assertIn("xml", public_formats)
80
81 self.assertIn("json2", all_formats)
82 self.assertIn("json2", public_formats)
83
84 self.assertIn("python", all_formats)
85 self.assertNotIn("python", public_formats)
86
87 def test_get_unknown_serializer(self):
88 """
89 #15889: get_serializer('nonsense') raises a SerializerDoesNotExist
90 """
91 with self.assertRaises(SerializerDoesNotExist):
92 serializers.get_serializer("nonsense")
93
94 with self.assertRaises(KeyError):
95 serializers.get_serializer("nonsense")
96
97 # SerializerDoesNotExist is instantiated with the nonexistent format
98 with self.assertRaisesMessage(SerializerDoesNotExist, "nonsense"):
99 serializers.get_serializer("nonsense")
100
101 def test_get_unknown_deserializer(self):
102 with self.assertRaises(SerializerDoesNotExist):
103 serializers.get_deserializer("nonsense")
104
105
106 class SerializersTestBase:
107 serializer_name = None # Set by subclasses to the serialization format name
108
109 @classmethod
110 def setUpTestData(cls):
111 sports = Category.objects.create(name="Sports")
112 music = Category.objects.create(name="Music")
113 op_ed = Category.objects.create(name="Op-Ed")
114
115 cls.joe = Author.objects.create(name="Joe")
116 cls.jane = Author.objects.create(name="Jane")
117
118 cls.a1 = Article(
119 author=cls.jane,
120 headline="Poker has no place on ESPN",
121 pub_date=datetime(2006, 6, 16, 11, 00),
122 )
123 cls.a1.save()
124 cls.a1.categories.set([sports, op_ed])
125
126 cls.a2 = Article(
127 author=cls.joe,
128 headline="Time to reform copyright",
129 pub_date=datetime(2006, 6, 16, 13, 00, 11, 345),
130 )
131 cls.a2.save()
132 cls.a2.categories.set([music, op_ed])
133
134 def test_serialize(self):
135 """Basic serialization works."""
136 serial_str = serializers.serialize(self.serializer_name, Article.objects.all())
137 self.assertTrue(self._validate_output(serial_str))
138
139 def test_serializer_roundtrip(self):
140 """Serialized content can be deserialized."""
141 serial_str = serializers.serialize(self.serializer_name, Article.objects.all())
142 models = list(serializers.deserialize(self.serializer_name, serial_str))
143 self.assertEqual(len(models), 2)
144
145 def test_serialize_to_stream(self):
146 obj = ComplexModel(field1="first", field2="second", field3="third")
147 obj.save_base(raw=True)
148
149 # Serialize the test database to a stream
150 for stream in (StringIO(), HttpResponse()):
151 serializers.serialize(self.serializer_name, [obj], indent=2, stream=stream)
152
153 # Serialize normally for a comparison
154 string_data = serializers.serialize(self.serializer_name, [obj], indent=2)
155
156 # The two are the same
157 if isinstance(stream, StringIO):
158 self.assertEqual(string_data, stream.getvalue())
159 else:
160 self.assertEqual(string_data, stream.text)
161
162 def test_serialize_specific_fields(self):
163 obj = ComplexModel(field1="first", field2="second", field3="third")
164 obj.save_base(raw=True)
165
166 # Serialize then deserialize the test database
167 serialized_data = serializers.serialize(
168 self.serializer_name, [obj], indent=2, fields=("field1", "field3")
169 )
170 result = next(serializers.deserialize(self.serializer_name, serialized_data))
171
172 # The deserialized object contains data in only the serialized fields.
173 self.assertEqual(result.object.field1, "first")
174 self.assertEqual(result.object.field2, "")
175 self.assertEqual(result.object.field3, "third")
176
177 def test_altering_serialized_output(self):
178 """
179 The ability to create new objects by modifying serialized content.
180 """
181 old_headline = "Poker has no place on ESPN"
182 new_headline = "Poker has no place on television"
183 serial_str = serializers.serialize(self.serializer_name, Article.objects.all())
184 serial_str = serial_str.replace(old_headline, new_headline)
185 models = list(serializers.deserialize(self.serializer_name, serial_str))
186
187 # Prior to saving, old headline is in place
188 self.assertTrue(Article.objects.filter(headline=old_headline))
189 self.assertFalse(Article.objects.filter(headline=new_headline))
190
191 for model in models:
192 model.save()
193
194 # After saving, new headline is in place
195 self.assertTrue(Article.objects.filter(headline=new_headline))
196 self.assertFalse(Article.objects.filter(headline=old_headline))
197
198 def test_one_to_one_as_pk(self):
199 """
200 If you use your own primary key field (such as a OneToOneField), it
201 doesn't appear in the serialized field list - it replaces the pk
202 identifier.
203 """
204 AuthorProfile.objects.create(
205 author=self.joe, date_of_birth=datetime(1970, 1, 1)
206 )
207 serial_str = serializers.serialize(
208 self.serializer_name, AuthorProfile.objects.all()
209 )
210 self.assertFalse(self._get_field_values(serial_str, "author"))
211
212 for obj in serializers.deserialize(self.serializer_name, serial_str):
213 self.assertEqual(obj.object.pk, self.joe.pk)
214
215 def test_serialize_field_subset(self):
216 """Output can be restricted to a subset of fields"""
217 valid_fields = ("headline", "pub_date")
218 invalid_fields = ("author", "categories")
219 serial_str = serializers.serialize(
220 self.serializer_name, Article.objects.all(), fields=valid_fields
221 )
222 for field_name in invalid_fields:
223 self.assertFalse(self._get_field_values(serial_str, field_name))
224
225 for field_name in valid_fields:
226 self.assertTrue(self._get_field_values(serial_str, field_name))
227
228 def test_serialize_unicode_roundtrip(self):
229 """Unicode makes the roundtrip intact"""
230 actor_name = "Za\u017c\u00f3\u0142\u0107"
231 movie_title = "G\u0119\u015bl\u0105 ja\u017a\u0144"
232 ac = Actor(name=actor_name)
233 mv = Movie(title=movie_title, actor=ac)
234 ac.save()
235 mv.save()
236
237 serial_str = serializers.serialize(self.serializer_name, [mv])
238 self.assertEqual(self._get_field_values(serial_str, "title")[0], movie_title)
239 self.assertEqual(self._get_field_values(serial_str, "actor")[0], actor_name)
240
241 obj_list = list(serializers.deserialize(self.serializer_name, serial_str))
242 mv_obj = obj_list[0].object
243 self.assertEqual(mv_obj.title, movie_title)
244
245 def test_unicode_serialization(self):
246 unicode_name = "יוניקוד"
247 data = serializers.serialize(self.serializer_name, [Author(name=unicode_name)])
248 self.assertIn(unicode_name, data)
249 objs = list(serializers.deserialize(self.serializer_name, data))
250 self.assertEqual(objs[0].object.name, unicode_name)
251
252 def test_serialize_progressbar(self):
253 fake_stdout = StringIO()
254 serializers.serialize(
255 self.serializer_name,
256 Article.objects.all(),
257 progress_output=fake_stdout,
258 object_count=Article.objects.count(),
259 )
260 self.assertTrue(
261 fake_stdout.getvalue().endswith(
262 "[" + "." * ProgressBar.progress_width + "]\n"
263 )
264 )
265
266 def test_serialize_superfluous_queries(self):
267 """Ensure no superfluous queries are made when serializing ForeignKeys
268
269 #17602
270 """
271 ac = Actor(name="Actor name")
272 ac.save()
273 mv = Movie(title="Movie title", actor_id=ac.pk)
274 mv.save()
275
276 with self.assertNumQueries(0):
277 serializers.serialize(self.serializer_name, [mv])
278
279 def test_serialize_prefetch_related_m2m(self):
280 # One query for the Article table, one for each prefetched m2m
281 # field, and one extra one for the nested prefetch for the Topics
282 # that have a relationship to the Category.
283 with self.assertNumQueries(5):
284 serializers.serialize(
285 self.serializer_name,
286 Article.objects.prefetch_related(
287 "meta_data",
288 "topics",
289 Prefetch(
290 "categories",
291 queryset=Category.objects.prefetch_related("topic_set"),
292 ),
293 ),
294 )
295 # One query for the Article table, and three m2m queries for each
296 # article.
297 with self.assertNumQueries(7):
298 serializers.serialize(self.serializer_name, Article.objects.all())
299
300 def test_serialize_prefetch_related_m2m_with_natural_keys(self):
301 # One query for the Article table, one for each prefetched m2m
302 # field, and a query to get the categories for each Article (two in
303 # total).
304 with self.assertNumQueries(5):
305 serializers.serialize(
306 self.serializer_name,
307 Article.objects.prefetch_related(
308 Prefetch(
309 "meta_data",
310 queryset=CategoryMetaData.objects.prefetch_related(
311 "category_set"
312 ),
313 ),
314 "topics",
315 ),
316 use_natural_foreign_keys=True,
317 )
318
319 def test_serialize_with_null_pk(self):
320 """
321 Serialized data with no primary key results
322 in a model instance with no id
323 """
324 category = Category(name="Reference")
325 serial_str = serializers.serialize(self.serializer_name, [category])
326 pk_value = self._get_pk_values(serial_str)[0]
327 self.assertFalse(pk_value)
328
329 cat_obj = list(serializers.deserialize(self.serializer_name, serial_str))[
330 0
331 ].object
332 self.assertIsNone(cat_obj.id)
333
334 def test_float_serialization(self):
335 """Float values serialize and deserialize intact"""
336 sc = Score(score=3.4)
337 sc.save()
338 serial_str = serializers.serialize(self.serializer_name, [sc])
339 deserial_objs = list(serializers.deserialize(self.serializer_name, serial_str))
340 self.assertEqual(deserial_objs[0].object.score, Approximate(3.4, places=1))
341
342 def test_deferred_field_serialization(self):
343 author = Author.objects.create(name="Victor Hugo")
344 author = Author.objects.defer("name").get(pk=author.pk)
345 serial_str = serializers.serialize(self.serializer_name, [author])
346 deserial_objs = list(serializers.deserialize(self.serializer_name, serial_str))
347 self.assertIsInstance(deserial_objs[0].object, Author)
348
349 def test_custom_field_serialization(self):
350 """Custom fields serialize and deserialize intact"""
351 team_str = "Spartak Moskva"
352 player = Player()
353 player.name = "Soslan Djanaev"
354 player.rank = 1
355 player.team = Team(team_str)
356 player.save()
357 serial_str = serializers.serialize(self.serializer_name, Player.objects.all())
358 team = self._get_field_values(serial_str, "team")
359 self.assertTrue(team)
360 self.assertEqual(team[0], team_str)
361
362 deserial_objs = list(serializers.deserialize(self.serializer_name, serial_str))
363 self.assertEqual(
364 deserial_objs[0].object.team.to_string(), player.team.to_string()
365 )
366
367 def test_pre_1000ad_date(self):
368 """Year values before 1000AD are properly formatted"""
369 # Regression for #12524 -- dates before 1000AD get prefixed
370 # 0's on the year
371 a = Article.objects.create(
372 author=self.jane,
373 headline="Nobody remembers the early years",
374 pub_date=datetime(1, 2, 3, 4, 5, 6),
375 )
376
377 serial_str = serializers.serialize(self.serializer_name, [a])
378 date_values = self._get_field_values(serial_str, "pub_date")
379 self.assertEqual(date_values[0].replace("T", " "), "0001-02-03 04:05:06")
380
381 def test_pkless_serialized_strings(self):
382 """
383 Serialized strings without PKs can be turned into models
384 """
385 deserial_objs = list(
386 serializers.deserialize(self.serializer_name, self.pkless_str)
387 )
388 for obj in deserial_objs:
389 self.assertFalse(obj.object.id)
390 obj.save()
391 self.assertEqual(Category.objects.count(), 5)
392
393 def test_deterministic_mapping_ordering(self):
394 """Mapping such as fields should be deterministically ordered. (#24558)"""
395 output = serializers.serialize(self.serializer_name, [self.a1], indent=2)
396 categories = self.a1.categories.values_list("pk", flat=True)
397 self.assertEqual(
398 output,
399 self.mapping_ordering_str
400 % {
401 "article_pk": self.a1.pk,
402 "author_pk": self.a1.author_id,
403 "first_category_pk": categories[0],
404 "second_category_pk": categories[1],
405 },
406 )
407
408 def test_deserialize_force_insert(self):
409 """Deserialized content can be saved with force_insert as a parameter."""
410 serial_str = serializers.serialize(self.serializer_name, [self.a1])
411 deserial_obj = list(serializers.deserialize(self.serializer_name, serial_str))[
412 0
413 ]
414 with mock.patch("django.db.models.Model") as mock_model:
415 deserial_obj.save(force_insert=False)
416 mock_model.save_base.assert_called_with(
417 deserial_obj.object, raw=True, using=None, force_insert=False
418 )
419
420 @skipUnlessDBFeature("can_defer_constraint_checks")
421 def test_serialize_proxy_model(self):
422 BaseModel.objects.create(parent_data=1)
423 base_objects = BaseModel.objects.all()
424 proxy_objects = ProxyBaseModel.objects.all()
425 proxy_proxy_objects = ProxyProxyBaseModel.objects.all()
426 base_data = serializers.serialize("json", base_objects)
427 proxy_data = serializers.serialize("json", proxy_objects)
428 proxy_proxy_data = serializers.serialize("json", proxy_proxy_objects)
429 self.assertEqual(base_data, proxy_data.replace("proxy", ""))
430 self.assertEqual(base_data, proxy_proxy_data.replace("proxy", ""))
431
432 def test_serialize_inherited_fields(self):
433 child_1 = Child.objects.create(parent_data="a", child_data="b")
434 child_2 = Child.objects.create(parent_data="c", child_data="d")
435 child_1.parent_m2m.add(child_2)
436 child_data = serializers.serialize(self.serializer_name, [child_1, child_2])
437 self.assertEqual(self._get_field_values(child_data, "parent_m2m"), [])
438 self.assertEqual(self._get_field_values(child_data, "parent_data"), [])
439
440 def test_serialize_only_pk(self):
441 with self.assertNumQueries(7) as ctx:
442 serializers.serialize(
443 self.serializer_name,
444 Article.objects.all(),
445 use_natural_foreign_keys=False,
446 )
447
448 categories_sql = ctx[1]["sql"]
449 self.assertNotIn(connection.ops.quote_name("meta_data_id"), categories_sql)
450 meta_data_sql = ctx[2]["sql"]
451 self.assertNotIn(connection.ops.quote_name("kind"), meta_data_sql)
452 topics_data_sql = ctx[3]["sql"]
453 self.assertNotIn(connection.ops.quote_name("category_id"), topics_data_sql)
454
455 def test_serialize_no_only_pk_with_natural_keys(self):
456 with self.assertNumQueries(7) as ctx:
457 serializers.serialize(
458 self.serializer_name,
459 Article.objects.all(),
460 use_natural_foreign_keys=True,
461 )
462
463 categories_sql = ctx[1]["sql"]
464 self.assertNotIn(connection.ops.quote_name("meta_data_id"), categories_sql)
465 # CategoryMetaData has natural_key().
466 meta_data_sql = ctx[2]["sql"]
467 self.assertIn(connection.ops.quote_name("kind"), meta_data_sql)
468 topics_data_sql = ctx[3]["sql"]
469 self.assertNotIn(connection.ops.quote_name("category_id"), topics_data_sql)
470
471
472 class SerializerAPITests(SimpleTestCase):
473 def test_stream_class(self):
474 class File:
475 def __init__(self):
476 self.lines = []
477
478 def write(self, line):
479 self.lines.append(line)
480
481 def getvalue(self):
482 return "".join(self.lines)
483
484 class Serializer(serializers.json.Serializer):
485 stream_class = File
486
487 serializer = Serializer()
488 data = serializer.serialize([Score(id=1, score=3.4)])
489 self.assertIs(serializer.stream_class, File)
490 self.assertIsInstance(serializer.stream, File)
491 self.assertEqual(
492 data, '[{"model": "serializers.score", "pk": 1, "fields": {"score": 3.4}}]'
493 )
494
495
496 class SerializersTransactionTestBase:
497 available_apps = ["serializers"]
498
499 @skipUnlessDBFeature("supports_forward_references")
500 def test_forward_refs(self):
501 """
502 Objects ids can be referenced before they are
503 defined in the serialization data.
504 """
505 # The deserialization process needs to run in a transaction in order
506 # to test forward reference handling.
507 with transaction.atomic():
508 objs = serializers.deserialize(self.serializer_name, self.fwd_ref_str)
509 with connection.constraint_checks_disabled():
510 for obj in objs:
511 obj.save()
512
513 for model_cls in (Category, Author, Article):
514 self.assertEqual(model_cls.objects.count(), 1)
515 art_obj = Article.objects.all()[0]
516 self.assertEqual(art_obj.categories.count(), 1)
517 self.assertEqual(art_obj.author.name, "Agnes")
518
519
520 def register_tests(test_class, method_name, test_func, exclude=()):
521 """
522 Dynamically create serializer tests to ensure that all registered
523 serializers are automatically tested.
524 """
525 for format_ in serializers.get_serializer_formats():
526 if format_ == "geojson" or format_ in exclude:
527 continue
528 decorated_func = skipIf(
529 isinstance(serializers.get_serializer(format_), serializers.BadSerializer),
530 "The Python library for the %s serializer is not installed." % format_,
531 )(test_func)
532 setattr(
533 test_class, method_name % format_, partialmethod(decorated_func, format_)
534 )