Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with HTTPS or Subversion.

Download ZIP
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
  • Loading branch information...
commit 7fbdeb49f90d596a2bd2374ce71419e20e2c5f8c 1 parent 592288f
@freakboy3742 freakboy3742 authored
Showing with 138 additions and 163 deletions.
  1. +1 −163 tests/modeltests/defer/models.py
  2. +137 −0 tests/modeltests/defer/tests.py
View
164 tests/modeltests/defer/models.py
@@ -3,7 +3,7 @@
"""
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()
-
-"""}
View
137 tests/modeltests/defer/tests.py
@@ -0,0 +1,137 @@
+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()
Please sign in to comment.
Something went wrong with that request. Please try again.