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()