diff options
author | Florian Apolloner <florian@apolloner.eu> | 2013-02-26 09:53:47 +0100 |
---|---|---|
committer | Florian Apolloner <florian@apolloner.eu> | 2013-02-26 14:36:57 +0100 |
commit | 89f40e36246100df6a11316c31a76712ebc6c501 (patch) | |
tree | 6e65639683ddaf2027908d1ecb1739e0e2ff853b /tests/defer | |
parent | b3d2ccb5bfbaf6e7fe1f98843baaa48c35a70950 (diff) | |
download | django-89f40e36246100df6a11316c31a76712ebc6c501.tar.gz |
Merged regressiontests and modeltests into the test root.
Diffstat (limited to 'tests/defer')
-rw-r--r-- | tests/defer/__init__.py | 0 | ||||
-rw-r--r-- | tests/defer/models.py | 30 | ||||
-rw-r--r-- | tests/defer/tests.py | 185 |
3 files changed, 215 insertions, 0 deletions
diff --git a/tests/defer/__init__.py b/tests/defer/__init__.py new file mode 100644 index 0000000000..e69de29bb2 --- /dev/null +++ b/tests/defer/__init__.py diff --git a/tests/defer/models.py b/tests/defer/models.py new file mode 100644 index 0000000000..0688cbc984 --- /dev/null +++ b/tests/defer/models.py @@ -0,0 +1,30 @@ +""" +Tests for defer() and only(). +""" + +from django.db import models +from django.utils.encoding import python_2_unicode_compatible + + +class Secondary(models.Model): + first = models.CharField(max_length=50) + second = models.CharField(max_length=50) + +@python_2_unicode_compatible +class Primary(models.Model): + name = models.CharField(max_length=50) + value = models.CharField(max_length=50) + related = models.ForeignKey(Secondary) + + def __str__(self): + return self.name + +class Child(Primary): + pass + +class BigChild(Primary): + other = models.CharField(max_length=50) + +class ChildProxy(Child): + class Meta: + proxy=True diff --git a/tests/defer/tests.py b/tests/defer/tests.py new file mode 100644 index 0000000000..50db5a76b4 --- /dev/null +++ b/tests/defer/tests.py @@ -0,0 +1,185 @@ +from __future__ import absolute_import + +from django.db.models.query_utils import DeferredAttribute, InvalidQuery +from django.test import TestCase + +from .models import Secondary, Primary, Child, BigChild, ChildProxy + + +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) + + # Using 'pk' with only() should result in 3 deferred fields, namely all + # of them except the model's primary key see #15494 + self.assert_delayed(qs.only("pk")[0], 3) + + obj = qs.select_related().only("related__first")[0] + self.assert_delayed(obj, 2) + + self.assertEqual(obj.related_id, s1.pk) + + # You can use 'pk' with reverse foreign key lookups. + self.assert_delayed(s1.primary_set.all().only('pk')[0], 3) + + 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) + + # When we defer a field and also select_related it, the query is + # invalid and raises an exception. + with self.assertRaises(InvalidQuery): + qs.only("name").select_related("related")[0] + with self.assertRaises(InvalidQuery): + qs.defer("related").select_related("related")[0] + + # With a depth-based select_related, all deferred ForeignKeys are + # deferred instead of traversed. + with self.assertNumQueries(3): + obj = qs.defer("related").select_related()[0] + self.assert_delayed(obj, 1) + self.assertEqual(obj.related.id, s1.pk) + + # 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() + + def test_defer_proxy(self): + """ + Ensure select_related together with only on a proxy model behaves + as expected. See #17876. + """ + related = Secondary.objects.create(first='x1', second='x2') + ChildProxy.objects.create(name='p1', value='xx', related=related) + children = ChildProxy.objects.all().select_related().only('id', 'name') + self.assertEqual(len(children), 1) + child = children[0] + self.assert_delayed(child, 2) + self.assertEqual(child.name, 'p1') + self.assertEqual(child.value, 'xx') + + def test_defer_inheritance_pk_chaining(self): + """ + When an inherited model is fetched from the DB, its PK is also fetched. + When getting the PK of the parent model it is useful to use the already + fetched parent model PK if it happens to be available. Tests that this + is done. + """ + s1 = Secondary.objects.create(first="x1", second="y1") + bc = BigChild.objects.create(name="b1", value="foo", related=s1, + other="bar") + bc_deferred = BigChild.objects.only('name').get(pk=bc.pk) + with self.assertNumQueries(0): + bc_deferred.id + self.assertEqual(bc_deferred.pk, bc_deferred.id) |