PageRenderTime 52ms CodeModel.GetById 6ms RepoModel.GetById 1ms app.codeStats 0ms

/tests/modeltests/serializers/tests.py

https://code.google.com/p/mango-py/
Python | 468 lines | 407 code | 33 blank | 28 comment | 6 complexity | 8d60417ff1bae4d559da1c05d1df91ff MD5 | raw file
Possible License(s): BSD-3-Clause
  1. # -*- coding: utf-8 -*-
  2. from datetime import datetime
  3. from StringIO import StringIO
  4. from xml.dom import minidom
  5. from django.conf import settings
  6. from django.core import serializers
  7. from django.db import transaction
  8. from django.test import TestCase, TransactionTestCase, Approximate
  9. from django.utils import simplejson, unittest
  10. from models import Category, Author, Article, AuthorProfile, Actor, \
  11. Movie, Score, Player, Team
  12. class SerializerRegistrationTests(unittest.TestCase):
  13. def setUp(self):
  14. self.old_SERIALIZATION_MODULES = getattr(settings, 'SERIALIZATION_MODULES', None)
  15. self.old_serializers = serializers._serializers
  16. serializers._serializers = {}
  17. settings.SERIALIZATION_MODULES = {
  18. "json2" : "django.core.serializers.json",
  19. }
  20. def tearDown(self):
  21. serializers._serializers = self.old_serializers
  22. if self.old_SERIALIZATION_MODULES:
  23. settings.SERIALIZATION_MODULES = self.old_SERIALIZATION_MODULES
  24. else:
  25. delattr(settings, 'SERIALIZATION_MODULES')
  26. def test_register(self):
  27. "Registering a new serializer populates the full registry. Refs #14823"
  28. serializers.register_serializer('json3', 'django.core.serializers.json')
  29. public_formats = serializers.get_public_serializer_formats()
  30. self.assertIn('json3', public_formats)
  31. self.assertIn('json2', public_formats)
  32. self.assertIn('xml', public_formats)
  33. def test_unregister(self):
  34. "Unregistering a serializer doesn't cause the registry to be repopulated. Refs #14823"
  35. serializers.unregister_serializer('xml')
  36. serializers.register_serializer('json3', 'django.core.serializers.json')
  37. public_formats = serializers.get_public_serializer_formats()
  38. self.assertNotIn('xml', public_formats)
  39. self.assertIn('json3', public_formats)
  40. def test_builtin_serializers(self):
  41. "Requesting a list of serializer formats popuates the registry"
  42. all_formats = set(serializers.get_serializer_formats())
  43. public_formats = set(serializers.get_public_serializer_formats())
  44. self.assertIn('xml', all_formats),
  45. self.assertIn('xml', public_formats)
  46. self.assertIn('json2', all_formats)
  47. self.assertIn('json2', public_formats)
  48. self.assertIn('python', all_formats)
  49. self.assertNotIn('python', public_formats)
  50. class SerializersTestBase(object):
  51. @staticmethod
  52. def _comparison_value(value):
  53. return value
  54. def setUp(self):
  55. sports = Category.objects.create(name="Sports")
  56. music = Category.objects.create(name="Music")
  57. op_ed = Category.objects.create(name="Op-Ed")
  58. self.joe = Author.objects.create(name="Joe")
  59. self.jane = Author.objects.create(name="Jane")
  60. self.a1 = Article(
  61. author=self.jane,
  62. headline="Poker has no place on ESPN",
  63. pub_date=datetime(2006, 6, 16, 11, 00)
  64. )
  65. self.a1.save()
  66. self.a1.categories = [sports, op_ed]
  67. self.a2 = Article(
  68. author=self.joe,
  69. headline="Time to reform copyright",
  70. pub_date=datetime(2006, 6, 16, 13, 00, 11, 345)
  71. )
  72. self.a2.save()
  73. self.a2.categories = [music, op_ed]
  74. def test_serialize(self):
  75. """Tests that basic serialization works."""
  76. serial_str = serializers.serialize(self.serializer_name,
  77. Article.objects.all())
  78. self.assertTrue(self._validate_output(serial_str))
  79. def test_serializer_roundtrip(self):
  80. """Tests that serialized content can be deserialized."""
  81. serial_str = serializers.serialize(self.serializer_name,
  82. Article.objects.all())
  83. models = list(serializers.deserialize(self.serializer_name, serial_str))
  84. self.assertEqual(len(models), 2)
  85. def test_altering_serialized_output(self):
  86. """
  87. Tests the ability to create new objects by
  88. modifying serialized content.
  89. """
  90. old_headline = "Poker has no place on ESPN"
  91. new_headline = "Poker has no place on television"
  92. serial_str = serializers.serialize(self.serializer_name,
  93. Article.objects.all())
  94. serial_str = serial_str.replace(old_headline, new_headline)
  95. models = list(serializers.deserialize(self.serializer_name, serial_str))
  96. # Prior to saving, old headline is in place
  97. self.assertTrue(Article.objects.filter(headline=old_headline))
  98. self.assertFalse(Article.objects.filter(headline=new_headline))
  99. for model in models:
  100. model.save()
  101. # After saving, new headline is in place
  102. self.assertTrue(Article.objects.filter(headline=new_headline))
  103. self.assertFalse(Article.objects.filter(headline=old_headline))
  104. def test_one_to_one_as_pk(self):
  105. """
  106. Tests that if you use your own primary key field
  107. (such as a OneToOneField), it doesn't appear in the
  108. serialized field list - it replaces the pk identifier.
  109. """
  110. profile = AuthorProfile(author=self.joe,
  111. date_of_birth=datetime(1970,1,1))
  112. profile.save()
  113. serial_str = serializers.serialize(self.serializer_name,
  114. AuthorProfile.objects.all())
  115. self.assertFalse(self._get_field_values(serial_str, 'author'))
  116. for obj in serializers.deserialize(self.serializer_name, serial_str):
  117. self.assertEqual(obj.object.pk, self._comparison_value(self.joe.pk))
  118. def test_serialize_field_subset(self):
  119. """Tests that output can be restricted to a subset of fields"""
  120. valid_fields = ('headline','pub_date')
  121. invalid_fields = ("author", "categories")
  122. serial_str = serializers.serialize(self.serializer_name,
  123. Article.objects.all(),
  124. fields=valid_fields)
  125. for field_name in invalid_fields:
  126. self.assertFalse(self._get_field_values(serial_str, field_name))
  127. for field_name in valid_fields:
  128. self.assertTrue(self._get_field_values(serial_str, field_name))
  129. def test_serialize_unicode(self):
  130. """Tests that unicode makes the roundtrip intact"""
  131. actor_name = u"Za\u017c\u00f3\u0142\u0107"
  132. movie_title = u'G\u0119\u015bl\u0105 ja\u017a\u0144'
  133. ac = Actor(name=actor_name)
  134. mv = Movie(title=movie_title, actor=ac)
  135. ac.save()
  136. mv.save()
  137. serial_str = serializers.serialize(self.serializer_name, [mv])
  138. self.assertEqual(self._get_field_values(serial_str, "title")[0], movie_title)
  139. self.assertEqual(self._get_field_values(serial_str, "actor")[0], actor_name)
  140. obj_list = list(serializers.deserialize(self.serializer_name, serial_str))
  141. mv_obj = obj_list[0].object
  142. self.assertEqual(mv_obj.title, movie_title)
  143. def test_serialize_with_null_pk(self):
  144. """
  145. Tests that serialized data with no primary key results
  146. in a model instance with no id
  147. """
  148. category = Category(name="Reference")
  149. serial_str = serializers.serialize(self.serializer_name, [category])
  150. pk_value = self._get_pk_values(serial_str)[0]
  151. self.assertFalse(pk_value)
  152. cat_obj = list(serializers.deserialize(self.serializer_name,
  153. serial_str))[0].object
  154. self.assertEqual(cat_obj.id, None)
  155. def test_float_serialization(self):
  156. """Tests that float values serialize and deserialize intact"""
  157. sc = Score(score=3.4)
  158. sc.save()
  159. serial_str = serializers.serialize(self.serializer_name, [sc])
  160. deserial_objs = list(serializers.deserialize(self.serializer_name,
  161. serial_str))
  162. self.assertEqual(deserial_objs[0].object.score, Approximate(3.4, places=1))
  163. def test_custom_field_serialization(self):
  164. """Tests that custom fields serialize and deserialize intact"""
  165. team_str = "Spartak Moskva"
  166. player = Player()
  167. player.name = "Soslan Djanaev"
  168. player.rank = 1
  169. player.team = Team(team_str)
  170. player.save()
  171. serial_str = serializers.serialize(self.serializer_name,
  172. Player.objects.all())
  173. team = self._get_field_values(serial_str, "team")
  174. self.assertTrue(team)
  175. self.assertEqual(team[0], team_str)
  176. deserial_objs = list(serializers.deserialize(self.serializer_name, serial_str))
  177. self.assertEqual(deserial_objs[0].object.team.to_string(),
  178. player.team.to_string())
  179. def test_pre_1000ad_date(self):
  180. """Tests that year values before 1000AD are properly formatted"""
  181. # Regression for #12524 -- dates before 1000AD get prefixed
  182. # 0's on the year
  183. a = Article.objects.create(
  184. author = self.jane,
  185. headline = "Nobody remembers the early years",
  186. pub_date = datetime(1, 2, 3, 4, 5, 6))
  187. serial_str = serializers.serialize(self.serializer_name, [a])
  188. date_values = self._get_field_values(serial_str, "pub_date")
  189. self.assertEqual(date_values[0], "0001-02-03 04:05:06")
  190. def test_pkless_serialized_strings(self):
  191. """
  192. Tests that serialized strings without PKs
  193. can be turned into models
  194. """
  195. deserial_objs = list(serializers.deserialize(self.serializer_name,
  196. self.pkless_str))
  197. for obj in deserial_objs:
  198. self.assertFalse(obj.object.id)
  199. obj.save()
  200. self.assertEqual(Category.objects.all().count(), 4)
  201. class SerializersTransactionTestBase(object):
  202. def test_forward_refs(self):
  203. """
  204. Tests that objects ids can be referenced before they are
  205. defined in the serialization data.
  206. """
  207. # The deserialization process needs to be contained
  208. # within a transaction in order to test forward reference
  209. # handling.
  210. transaction.enter_transaction_management()
  211. transaction.managed(True)
  212. objs = serializers.deserialize(self.serializer_name, self.fwd_ref_str)
  213. for obj in objs:
  214. obj.save()
  215. transaction.commit()
  216. transaction.leave_transaction_management()
  217. for model_cls in (Category, Author, Article):
  218. self.assertEqual(model_cls.objects.all().count(), 1)
  219. art_obj = Article.objects.all()[0]
  220. self.assertEqual(art_obj.categories.all().count(), 1)
  221. self.assertEqual(art_obj.author.name, "Agnes")
  222. class XmlSerializerTestCase(SerializersTestBase, TestCase):
  223. serializer_name = "xml"
  224. pkless_str = """<?xml version="1.0" encoding="utf-8"?>
  225. <django-objects version="1.0">
  226. <object model="serializers.category">
  227. <field type="CharField" name="name">Reference</field>
  228. </object>
  229. </django-objects>"""
  230. @staticmethod
  231. def _comparison_value(value):
  232. # The XML serializer handles everything as strings, so comparisons
  233. # need to be performed on the stringified value
  234. return unicode(value)
  235. @staticmethod
  236. def _validate_output(serial_str):
  237. try:
  238. minidom.parseString(serial_str)
  239. except Exception:
  240. return False
  241. else:
  242. return True
  243. @staticmethod
  244. def _get_pk_values(serial_str):
  245. ret_list = []
  246. dom = minidom.parseString(serial_str)
  247. fields = dom.getElementsByTagName("object")
  248. for field in fields:
  249. ret_list.append(field.getAttribute("pk"))
  250. return ret_list
  251. @staticmethod
  252. def _get_field_values(serial_str, field_name):
  253. ret_list = []
  254. dom = minidom.parseString(serial_str)
  255. fields = dom.getElementsByTagName("field")
  256. for field in fields:
  257. if field.getAttribute("name") == field_name:
  258. temp = []
  259. for child in field.childNodes:
  260. temp.append(child.nodeValue)
  261. ret_list.append("".join(temp))
  262. return ret_list
  263. class XmlSerializerTransactionTestCase(SerializersTransactionTestBase, TransactionTestCase):
  264. serializer_name = "xml"
  265. fwd_ref_str = """<?xml version="1.0" encoding="utf-8"?>
  266. <django-objects version="1.0">
  267. <object pk="1" model="serializers.article">
  268. <field to="serializers.author" name="author" rel="ManyToOneRel">1</field>
  269. <field type="CharField" name="headline">Forward references pose no problem</field>
  270. <field type="DateTimeField" name="pub_date">2006-06-16 15:00:00</field>
  271. <field to="serializers.category" name="categories" rel="ManyToManyRel">
  272. <object pk="1"></object>
  273. </field>
  274. </object>
  275. <object pk="1" model="serializers.author">
  276. <field type="CharField" name="name">Agnes</field>
  277. </object>
  278. <object pk="1" model="serializers.category">
  279. <field type="CharField" name="name">Reference</field></object>
  280. </django-objects>"""
  281. class JsonSerializerTestCase(SerializersTestBase, TestCase):
  282. serializer_name = "json"
  283. pkless_str = """[{"pk": null, "model": "serializers.category", "fields": {"name": "Reference"}}]"""
  284. @staticmethod
  285. def _validate_output(serial_str):
  286. try:
  287. simplejson.loads(serial_str)
  288. except Exception:
  289. return False
  290. else:
  291. return True
  292. @staticmethod
  293. def _get_pk_values(serial_str):
  294. ret_list = []
  295. serial_list = simplejson.loads(serial_str)
  296. for obj_dict in serial_list:
  297. ret_list.append(obj_dict["pk"])
  298. return ret_list
  299. @staticmethod
  300. def _get_field_values(serial_str, field_name):
  301. ret_list = []
  302. serial_list = simplejson.loads(serial_str)
  303. for obj_dict in serial_list:
  304. if field_name in obj_dict["fields"]:
  305. ret_list.append(obj_dict["fields"][field_name])
  306. return ret_list
  307. class JsonSerializerTransactionTestCase(SerializersTransactionTestBase, TransactionTestCase):
  308. serializer_name = "json"
  309. fwd_ref_str = """[
  310. {
  311. "pk": 1,
  312. "model": "serializers.article",
  313. "fields": {
  314. "headline": "Forward references pose no problem",
  315. "pub_date": "2006-06-16 15:00:00",
  316. "categories": [1],
  317. "author": 1
  318. }
  319. },
  320. {
  321. "pk": 1,
  322. "model": "serializers.category",
  323. "fields": {
  324. "name": "Reference"
  325. }
  326. },
  327. {
  328. "pk": 1,
  329. "model": "serializers.author",
  330. "fields": {
  331. "name": "Agnes"
  332. }
  333. }]"""
  334. try:
  335. import yaml
  336. except ImportError:
  337. pass
  338. else:
  339. class YamlSerializerTestCase(SerializersTestBase, TestCase):
  340. serializer_name = "yaml"
  341. fwd_ref_str = """- fields:
  342. headline: Forward references pose no problem
  343. pub_date: 2006-06-16 15:00:00
  344. categories: [1]
  345. author: 1
  346. pk: 1
  347. model: serializers.article
  348. - fields:
  349. name: Reference
  350. pk: 1
  351. model: serializers.category
  352. - fields:
  353. name: Agnes
  354. pk: 1
  355. model: serializers.author"""
  356. pkless_str = """- fields:
  357. name: Reference
  358. pk: null
  359. model: serializers.category"""
  360. @staticmethod
  361. def _validate_output(serial_str):
  362. try:
  363. yaml.load(StringIO(serial_str))
  364. except Exception:
  365. return False
  366. else:
  367. return True
  368. @staticmethod
  369. def _get_pk_values(serial_str):
  370. ret_list = []
  371. stream = StringIO(serial_str)
  372. for obj_dict in yaml.load(stream):
  373. ret_list.append(obj_dict["pk"])
  374. return ret_list
  375. @staticmethod
  376. def _get_field_values(serial_str, field_name):
  377. ret_list = []
  378. stream = StringIO(serial_str)
  379. for obj_dict in yaml.load(stream):
  380. if "fields" in obj_dict and field_name in obj_dict["fields"]:
  381. field_value = obj_dict["fields"][field_name]
  382. # yaml.load will return non-string objects for some
  383. # of the fields we are interested in, this ensures that
  384. # everything comes back as a string
  385. if isinstance(field_value, basestring):
  386. ret_list.append(field_value)
  387. else:
  388. ret_list.append(str(field_value))
  389. return ret_list
  390. class YamlSerializerTransactionTestCase(SerializersTransactionTestBase, TransactionTestCase):
  391. serializer_name = "yaml"
  392. fwd_ref_str = """- fields:
  393. headline: Forward references pose no problem
  394. pub_date: 2006-06-16 15:00:00
  395. categories: [1]
  396. author: 1
  397. pk: 1
  398. model: serializers.article
  399. - fields:
  400. name: Reference
  401. pk: 1
  402. model: serializers.category
  403. - fields:
  404. name: Agnes
  405. pk: 1
  406. model: serializers.author"""