Ticket #15184: foreignkey_subclass_patch.20141018.diff

django/db/models/fields/subclassing.py

@@ -32 +32 @@
     """
     A placeholder class that provides a way to set the attribute on the model.
     """
-    def __init__(self, field):
+    def __init__(self, field, old_descr=None):
         self.field = field
+        self.old_descr = old_descr
 
     def __get__(self, obj, type=None):
         if obj is None:
             return self
-        return obj.__dict__[self.field.name]
+        if self.old_descr:
+            return self.old_descr.__get__(obj, type)
+        else:
+            return obj.__dict__[self.field.name]
 
     def __set__(self, obj, value):
-        obj.__dict__[self.field.name] = self.field.to_python(value)
+        val = self.field.to_python(value)
+        if self.old_descr:
+            self.old_descr.__set__(obj, val)
+        else:
+            obj.__dict__[self.field.name] = val
 
 
 def make_contrib(superclass, func=None):
@@ -58 +66 @@
             func(self, cls, name, **kwargs)
         else:
             super(superclass, self).contribute_to_class(cls, name, **kwargs)
-        setattr(cls, self.name, Creator(self))
+        # If this value already exists on the class it is likely a descriptor
+        # for related fields. Keep it around so we can call it from our
+        # descriptor.
+        old_descr = cls.__dict__.get(self.name)
+        setattr(cls, self.name, Creator(self, old_descr))
 
     return contribute_to_class

tests/field_subclassing/fields.py

@@ -94 +94 @@
 class CustomTypedField(models.TextField):
     def db_type(self, connection):
         return 'custom_field'
+
+
+class FKSubField(models.ForeignKey):
+    """
+    Subclass ForeignKey to check descriptor overloading. Confirms ticket
+    #15184 has been corrected.
+    """
+    __metaclass__ = models.SubfieldBase
+
+    def __init__(self, cls, *args, **kwargs):
+        super(FKSubField, self).__init__(cls, *args, **kwargs)
+
+    def to_python(self, value):
+        return value

tests/field_subclassing/models.py

@@ -4 +4 @@
 from django.db import models
 from django.utils.encoding import force_text
 
-from .fields import Small, SmallField, SmallerField, JSONField
+from .fields import Small, SmallField, SmallerField, JSONField, FKSubField
 from django.utils.encoding import python_2_unicode_compatible
 
 
@@ -33 +33 @@
 
 class DataModel(models.Model):
     data = JSONField()
+
+
+class FKModel(models.Model):
+    data = FKSubField(MyModel)

tests/field_subclassing/tests.py

@@ -5 +5 @@
 from django.core import exceptions, serializers
 from django.db import connection
 from django.test import TestCase
+from django.core.exceptions import ObjectDoesNotExist
 
 from .fields import Small, CustomTypedField
-from .models import ChoicesModel, DataModel, MyModel, OtherModel
+from .models import ChoicesModel, DataModel, MyModel, OtherModel, FKModel
 
 
 class CustomField(TestCase):
@@ -94 +95 @@
         self.assertEqual(o.data.first, "a")
         self.assertEqual(o.data.second, "b")
 
+    def test_foreignkey_subclassing(self):
+        obj = FKModel()
+
+        # We have to do something a bit funky to catch this exception due to
+        # it originating in a descriptor.
+        okay = False
+        try:
+            # The next line would have raised a KeyError prior to being fixed.
+            val = obj.data
+        except ObjectDoesNotExist:
+            okay = True
+        self.assertEquals(okay, True)
+
+        target = MyModel.objects.create(name="1", data=Small(1, 2))
+        obj.data = target
+        obj.save()
+        self.assertEqual(obj.data, target)
+
     def test_subfieldbase_plays_nice_with_module_inspect(self):
         """
         Custom fields should play nice with python standard module inspect.