Commit 7fbdeb49 authored by Russell Keith-Magee's avatar Russell Keith-Magee
Browse files

[1.2.X] Migrated defer doctests. Thanks to Alex Gaynor. 

Backport of r13777 from trunk.

git-svn-id: http://code.djangoproject.com/svn/django/branches/releases/1.2.X@13794 bcc190cf-cafb-0310-a4f2-bffc1f526a37
parent 592288fb

tests/modeltests/defer/models.py

+1 −163
Original line number Diff line number Diff line
@@ -3,7 +3,7 @@ Tests for defer() and only(). 
"""



from django.db import models

from django.db.models.query_utils import DeferredAttribute





class Secondary(models.Model):

    first = models.CharField(max_length=50)
@@ -22,165 +22,3 @@ class Child(Primary): 


class BigChild(Primary):

    other = models.CharField(max_length=50)
 


def count_delayed_fields(obj, debug=False):

    """

    Returns the number of delayed attributes on the given model instance.

    """

    count = 0

    for field in obj._meta.fields:

        if isinstance(obj.__class__.__dict__.get(field.attname),

                DeferredAttribute):

            if debug:

                print field.name, field.attname

            count += 1

    return count





__test__ = {"API_TEST": """

To all outward appearances, instances with deferred fields look the same as

normal instances when we examine attribute values. Therefore we test for the

number of deferred fields on returned instances (by poking at the internals),

as a way to observe what is going on.



>>> s1 = Secondary.objects.create(first="x1", second="y1")

>>> p1 = Primary.objects.create(name="p1", value="xx", related=s1)



>>> qs = Primary.objects.all()



>>> count_delayed_fields(qs.defer('name')[0])

1

>>> count_delayed_fields(qs.only('name')[0])

2

>>> count_delayed_fields(qs.defer('related__first')[0])

0

>>> obj = qs.select_related().only('related__first')[0]

>>> count_delayed_fields(obj)

2

>>> obj.related_id == s1.pk

True

>>> count_delayed_fields(qs.defer('name').extra(select={'a': 1})[0])

1

>>> count_delayed_fields(qs.extra(select={'a': 1}).defer('name')[0])

1

>>> count_delayed_fields(qs.defer('name').defer('value')[0])

2

>>> count_delayed_fields(qs.only('name').only('value')[0])

2

>>> count_delayed_fields(qs.only('name').defer('value')[0])

2

>>> count_delayed_fields(qs.only('name', 'value').defer('value')[0])

2

>>> count_delayed_fields(qs.defer('name').only('value')[0])

2

>>> obj = qs.only()[0]

>>> count_delayed_fields(qs.defer(None)[0])

0

>>> count_delayed_fields(qs.only('name').defer(None)[0])

0



User values() won't defer anything (you get the full list of dictionaries

back), but it still works.

>>> qs.defer('name').values()[0] == {'id': p1.id, 'name': u'p1', 'value': 'xx', 'related_id': s1.id}

True

>>> qs.only('name').values()[0] == {'id': p1.id, 'name': u'p1', 'value': 'xx', 'related_id': s1.id}

True



Using defer() and only() with get() is also valid.

>>> count_delayed_fields(qs.defer('name').get(pk=p1.pk))

1

>>> count_delayed_fields(qs.only('name').get(pk=p1.pk))

2



# KNOWN NOT TO WORK: >>> count_delayed_fields(qs.only('name').select_related('related')[0])

# KNOWN NOT TO WORK >>> count_delayed_fields(qs.defer('related').select_related('related')[0])



# Saving models with deferred fields is possible (but inefficient, since every

# field has to be retrieved first).



>>> obj = Primary.objects.defer("value").get(name="p1")

>>> obj.name = "a new name"

>>> obj.save()

>>> Primary.objects.all()

[<Primary: a new name>]



# Regression for #10572 - A subclass with no extra fields can defer fields from the base class

>>> _ = Child.objects.create(name="c1", value="foo", related=s1)



# You can defer a field on a baseclass when the subclass has no fields

>>> obj = Child.objects.defer("value").get(name="c1")

>>> count_delayed_fields(obj)

1

>>> obj.name

u"c1"

>>> obj.value

u"foo"

>>> obj.name = "c2"

>>> obj.save()



# You can retrive a single column on a base class with no fields

>>> obj = Child.objects.only("name").get(name="c2")

>>> count_delayed_fields(obj)

3

>>> obj.name

u"c2"

>>> obj.value

u"foo"

>>> obj.name = "cc"

>>> obj.save()



>>> _ = BigChild.objects.create(name="b1", value="foo", related=s1, other="bar")



# You can defer a field on a baseclass

>>> obj = BigChild.objects.defer("value").get(name="b1")

>>> count_delayed_fields(obj)

1

>>> obj.name

u"b1"

>>> obj.value

u"foo"

>>> obj.other

u"bar"

>>> obj.name = "b2"

>>> obj.save()



# You can defer a field on a subclass

>>> obj = BigChild.objects.defer("other").get(name="b2")

>>> count_delayed_fields(obj)

1

>>> obj.name

u"b2"

>>> obj.value

u"foo"

>>> obj.other

u"bar"

>>> obj.name = "b3"

>>> obj.save()



# You can retrieve a single field on a baseclass

>>> obj = BigChild.objects.only("name").get(name="b3")

>>> count_delayed_fields(obj)

4

>>> obj.name

u"b3"

>>> obj.value

u"foo"

>>> obj.other

u"bar"

>>> obj.name = "b4"

>>> obj.save()



# You can retrieve a single field on a baseclass

>>> obj = BigChild.objects.only("other").get(name="b4")

>>> count_delayed_fields(obj)

4

>>> obj.name

u"b4"

>>> obj.value

u"foo"

>>> obj.other

u"bar"

>>> obj.name = "bb"

>>> obj.save()



"""}

tests/modeltests/defer/tests.py

0 → 100644
+137 −0
Original line number Diff line number Diff line 
from django.db.models.query_utils import DeferredAttribute

from django.test import TestCase



from models import Secondary, Primary, Child, BigChild





class DeferTests(TestCase):

    def assert_delayed(self, obj, num):

        count = 0

        for field in obj._meta.fields:

            if isinstance(obj.__class__.__dict__.get(field.attname),

                DeferredAttribute):

                count += 1

        self.assertEqual(count, num)



    def test_defer(self):

        # To all outward appearances, instances with deferred fields look the

        # same as normal instances when we examine attribute values. Therefore

        # we test for the number of deferred fields on returned instances (by

        # poking at the internals), as a way to observe what is going on.



        s1 = Secondary.objects.create(first="x1", second="y1")

        p1 = Primary.objects.create(name="p1", value="xx", related=s1)



        qs = Primary.objects.all()



        self.assert_delayed(qs.defer("name")[0], 1)

        self.assert_delayed(qs.only("name")[0], 2)

        self.assert_delayed(qs.defer("related__first")[0], 0)



        obj = qs.select_related().only("related__first")[0]

        self.assert_delayed(obj, 2)



        self.assertEqual(obj.related_id, s1.pk)



        self.assert_delayed(qs.defer("name").extra(select={"a": 1})[0], 1)

        self.assert_delayed(qs.extra(select={"a": 1}).defer("name")[0], 1)

        self.assert_delayed(qs.defer("name").defer("value")[0], 2)

        self.assert_delayed(qs.only("name").only("value")[0], 2)

        self.assert_delayed(qs.only("name").defer("value")[0], 2)

        self.assert_delayed(qs.only("name", "value").defer("value")[0], 2)

        self.assert_delayed(qs.defer("name").only("value")[0], 2)



        obj = qs.only()[0]

        self.assert_delayed(qs.defer(None)[0], 0)

        self.assert_delayed(qs.only("name").defer(None)[0], 0)



        # User values() won't defer anything (you get the full list of

        # dictionaries back), but it still works.

        self.assertEqual(qs.defer("name").values()[0], {

            "id": p1.id,

            "name": "p1",

            "value": "xx",

            "related_id": s1.id,

        })

        self.assertEqual(qs.only("name").values()[0], {

            "id": p1.id,

            "name": "p1",

            "value": "xx",

            "related_id": s1.id,

        })



        # Using defer() and only() with get() is also valid.

        self.assert_delayed(qs.defer("name").get(pk=p1.pk), 1)

        self.assert_delayed(qs.only("name").get(pk=p1.pk), 2)



        # DOES THIS WORK?

        self.assert_delayed(qs.only("name").select_related("related")[0], 1)

        self.assert_delayed(qs.defer("related").select_related("related")[0], 0)



        # Saving models with deferred fields is possible (but inefficient,

        # since every field has to be retrieved first).

        obj = Primary.objects.defer("value").get(name="p1")

        obj.name = "a new name"

        obj.save()

        self.assertQuerysetEqual(

            Primary.objects.all(), [

                "a new name",

            ],

            lambda p: p.name

        )



        # Regression for #10572 - A subclass with no extra fields can defer

        # fields from the base class

        Child.objects.create(name="c1", value="foo", related=s1)

        # You can defer a field on a baseclass when the subclass has no fields

        obj = Child.objects.defer("value").get(name="c1")

        self.assert_delayed(obj, 1)

        self.assertEqual(obj.name, "c1")

        self.assertEqual(obj.value, "foo")

        obj.name = "c2"

        obj.save()



        # You can retrive a single column on a base class with no fields

        obj = Child.objects.only("name").get(name="c2")

        self.assert_delayed(obj, 3)

        self.assertEqual(obj.name, "c2")

        self.assertEqual(obj.value, "foo")

        obj.name = "cc"

        obj.save()



        BigChild.objects.create(name="b1", value="foo", related=s1, other="bar")

        # You can defer a field on a baseclass

        obj = BigChild.objects.defer("value").get(name="b1")

        self.assert_delayed(obj, 1)

        self.assertEqual(obj.name, "b1")

        self.assertEqual(obj.value, "foo")

        self.assertEqual(obj.other, "bar")

        obj.name = "b2"

        obj.save()



        # You can defer a field on a subclass

        obj = BigChild.objects.defer("other").get(name="b2")

        self.assert_delayed(obj, 1)

        self.assertEqual(obj.name, "b2")

        self.assertEqual(obj.value, "foo")

        self.assertEqual(obj.other, "bar")

        obj.name = "b3"

        obj.save()



        # You can retrieve a single field on a baseclass

        obj = BigChild.objects.only("name").get(name="b3")

        self.assert_delayed(obj, 4)

        self.assertEqual(obj.name, "b3")

        self.assertEqual(obj.value, "foo")

        self.assertEqual(obj.other, "bar")

        obj.name = "b4"

        obj.save()



        # You can retrieve a single field on a baseclass

        obj = BigChild.objects.only("other").get(name="b4")

        self.assert_delayed(obj, 4)

        self.assertEqual(obj.name, "b4")

        self.assertEqual(obj.value, "foo")

        self.assertEqual(obj.other, "bar")

        obj.name = "bb"

        obj.save()