← Back to branch summary

~ubuntu-branches/debian/sid/python-django/sid

« back to all changes in this revision

Viewing changes to tests/queryset_pickle/tests.py

  • Committer: Package Import Robot
  • Author(s): Luke Faraone
  • Date: 2013-11-07 15:33:49 UTC
  • mfrom: (1.3.12)
  • Revision ID: package-import@ubuntu.com-20131107153349-e31sc149l2szs3jb
Tags: 1.6-1
http://bugs.debian.org/557474
http://bugs.debian.org/724637
http://bugs.debian.org/636511
http://bugs.debian.org/686333
http://bugs.debian.org/704203
* New upstream version. Closes: #557474, #724637.
* python-django now also suggests the installation of ipython,
  bpython, python-django-doc, and libgdal1.
  Closes: #636511, #686333, #704203
* Set package maintainer to Debian Python Modules Team.
* Bump standards version to 3.9.5, no changes needed.

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/queryset_pickle/tests.py
 
1
from __future__ import absolute_import
 
2
 
 
3
import pickle
 
4
import datetime
 
5
 
 
6
from django.db import models
 
7
from django.test import TestCase
 
8
 
 
9
from .models import Group, Event, Happening, Container, M2MModel
 
10
 
 
11
 
 
12
class PickleabilityTestCase(TestCase):
 
13
    def setUp(self):
 
14
        Happening.objects.create() # make sure the defaults are working (#20158)
 
15
 
 
16
    def assert_pickles(self, qs):
 
17
        self.assertEqual(list(pickle.loads(pickle.dumps(qs))), list(qs))
 
18
 
 
19
    def test_related_field(self):
 
20
        g = Group.objects.create(name="Ponies Who Own Maybachs")
 
21
        self.assert_pickles(Event.objects.filter(group=g.id))
 
22
 
 
23
    def test_datetime_callable_default_all(self):
 
24
        self.assert_pickles(Happening.objects.all())
 
25
 
 
26
    def test_datetime_callable_default_filter(self):
 
27
        self.assert_pickles(Happening.objects.filter(when=datetime.datetime.now()))
 
28
 
 
29
    def test_lambda_as_default(self):
 
30
        self.assert_pickles(Happening.objects.filter(name="test"))
 
31
 
 
32
    def test_standalone_method_as_default(self):
 
33
        self.assert_pickles(Happening.objects.filter(number1=1))
 
34
 
 
35
    def test_staticmethod_as_default(self):
 
36
        self.assert_pickles(Happening.objects.filter(number2=1))
 
37
 
 
38
    def test_classmethod_as_default(self):
 
39
        self.assert_pickles(Happening.objects.filter(number3=1))
 
40
 
 
41
    def test_membermethod_as_default(self):
 
42
        self.assert_pickles(Happening.objects.filter(number4=1))
 
43
 
 
44
    def test_doesnotexist_exception(self):
 
45
        # Ticket #17776
 
46
        original = Event.DoesNotExist("Doesn't exist")
 
47
        unpickled = pickle.loads(pickle.dumps(original))
 
48
 
 
49
        # Exceptions are not equal to equivalent instances of themselves, so
 
50
        # can't just use assertEqual(original, unpickled)
 
51
        self.assertEqual(original.__class__, unpickled.__class__)
 
52
        self.assertEqual(original.args, unpickled.args)
 
53
 
 
54
    def test_model_pickle(self):
 
55
        """
 
56
        Test that a model not defined on module level is pickleable.
 
57
        """
 
58
        original = Container.SomeModel(pk=1)
 
59
        dumped = pickle.dumps(original)
 
60
        reloaded = pickle.loads(dumped)
 
61
        self.assertEqual(original, reloaded)
 
62
        # Also, deferred dynamic model works
 
63
        Container.SomeModel.objects.create(somefield=1)
 
64
        original = Container.SomeModel.objects.defer('somefield')[0]
 
65
        dumped = pickle.dumps(original)
 
66
        reloaded = pickle.loads(dumped)
 
67
        self.assertEqual(original, reloaded)
 
68
        self.assertEqual(original.somefield, reloaded.somefield)
 
69
 
 
70
    def test_model_pickle_m2m(self):
 
71
        """
 
72
        Test intentionally the automatically created through model.
 
73
        """
 
74
        m1 = M2MModel.objects.create()
 
75
        g1 = Group.objects.create(name='foof')
 
76
        m1.groups.add(g1)
 
77
        m2m_through = M2MModel._meta.get_field_by_name('groups')[0].rel.through
 
78
        original = m2m_through.objects.get()
 
79
        dumped = pickle.dumps(original)
 
80
        reloaded = pickle.loads(dumped)
 
81
        self.assertEqual(original, reloaded)
 
82
 
 
83
    def test_model_pickle_dynamic(self):
 
84
        class Meta:
 
85
            proxy = True
 
86
        dynclass = type("DynamicEventSubclass", (Event, ),
 
87
                        {'Meta': Meta, '__module__': Event.__module__})
 
88
        original = dynclass(pk=1)
 
89
        dumped = pickle.dumps(original)
 
90
        reloaded = pickle.loads(dumped)
 
91
        self.assertEqual(original, reloaded)
 
92
        self.assertIs(reloaded.__class__, dynclass)
 
93
 
 
94
    def test_pickle_prefetch_related_idempotence(self):
 
95
        g = Group.objects.create(name='foo')
 
96
        groups = Group.objects.prefetch_related('event_set')
 
97
 
 
98
        # First pickling
 
99
        groups = pickle.loads(pickle.dumps(groups))
 
100
        self.assertQuerysetEqual(groups, [g], lambda x: x)
 
101
 
 
102
        # Second pickling
 
103
        groups = pickle.loads(pickle.dumps(groups))
 
104
        self.assertQuerysetEqual(groups, [g], lambda x: x)