diff options
Diffstat (limited to 'parts/django/tests/modeltests/field_subclassing')
4 files changed, 177 insertions, 0 deletions
diff --git a/parts/django/tests/modeltests/field_subclassing/__init__.py b/parts/django/tests/modeltests/field_subclassing/__init__.py new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/parts/django/tests/modeltests/field_subclassing/__init__.py diff --git a/parts/django/tests/modeltests/field_subclassing/fields.py b/parts/django/tests/modeltests/field_subclassing/fields.py new file mode 100644 index 0000000..8675b31 --- /dev/null +++ b/parts/django/tests/modeltests/field_subclassing/fields.py @@ -0,0 +1,74 @@ +from django.core.exceptions import FieldError +from django.db import models +from django.utils import simplejson as json +from django.utils.encoding import force_unicode + + +class Small(object): + """ + A simple class to show that non-trivial Python objects can be used as + attributes. + """ + def __init__(self, first, second): + self.first, self.second = first, second + + def __unicode__(self): + return u'%s%s' % (force_unicode(self.first), force_unicode(self.second)) + + def __str__(self): + return unicode(self).encode('utf-8') + +class SmallField(models.Field): + """ + Turns the "Small" class into a Django field. Because of the similarities + with normal character fields and the fact that Small.__unicode__ does + something sensible, we don't need to implement a lot here. + """ + __metaclass__ = models.SubfieldBase + + def __init__(self, *args, **kwargs): + kwargs['max_length'] = 2 + super(SmallField, self).__init__(*args, **kwargs) + + def get_internal_type(self): + return 'CharField' + + def to_python(self, value): + if isinstance(value, Small): + return value + return Small(value[0], value[1]) + + def get_db_prep_save(self, value): + return unicode(value) + + def get_prep_lookup(self, lookup_type, value): + if lookup_type == 'exact': + return force_unicode(value) + if lookup_type == 'in': + return [force_unicode(v) for v in value] + if lookup_type == 'isnull': + return [] + raise TypeError('Invalid lookup type: %r' % lookup_type) + +class SmallerField(SmallField): + pass + + +class JSONField(models.TextField): + __metaclass__ = models.SubfieldBase + + description = ("JSONField automatically serializes and desializes values to " + "and from JSON.") + + def to_python(self, value): + if not value: + return None + + if isinstance(value, basestring): + value = json.loads(value) + return value + + def get_db_prep_save(self, value): + if value is None: + return None + return json.dumps(value) diff --git a/parts/django/tests/modeltests/field_subclassing/models.py b/parts/django/tests/modeltests/field_subclassing/models.py new file mode 100644 index 0000000..b0d8336 --- /dev/null +++ b/parts/django/tests/modeltests/field_subclassing/models.py @@ -0,0 +1,22 @@ +""" +Tests for field subclassing. +""" + +from django.db import models +from django.utils.encoding import force_unicode + +from fields import Small, SmallField, SmallerField, JSONField + + +class MyModel(models.Model): + name = models.CharField(max_length=10) + data = SmallField('small field') + + def __unicode__(self): + return force_unicode(self.name) + +class OtherModel(models.Model): + data = SmallerField() + +class DataModel(models.Model): + data = JSONField() diff --git a/parts/django/tests/modeltests/field_subclassing/tests.py b/parts/django/tests/modeltests/field_subclassing/tests.py new file mode 100644 index 0000000..25f5160 --- /dev/null +++ b/parts/django/tests/modeltests/field_subclassing/tests.py @@ -0,0 +1,81 @@ +from django.core import serializers +from django.test import TestCase + +from fields import Small +from models import DataModel, MyModel, OtherModel + + +class CustomField(TestCase): + def test_defer(self): + d = DataModel.objects.create(data=[1, 2, 3]) + + self.assertTrue(isinstance(d.data, list)) + + d = DataModel.objects.get(pk=d.pk) + self.assertTrue(isinstance(d.data, list)) + self.assertEqual(d.data, [1, 2, 3]) + + d = DataModel.objects.defer("data").get(pk=d.pk) + d.save() + + d = DataModel.objects.get(pk=d.pk) + self.assertTrue(isinstance(d.data, list)) + self.assertEqual(d.data, [1, 2, 3]) + + def test_custom_field(self): + # Creating a model with custom fields is done as per normal. + s = Small(1, 2) + self.assertEqual(str(s), "12") + + m = MyModel.objects.create(name="m", data=s) + # Custom fields still have normal field's attributes. + self.assertEqual(m._meta.get_field("data").verbose_name, "small field") + + # The m.data attribute has been initialised correctly. It's a Small + # object. + self.assertEqual((m.data.first, m.data.second), (1, 2)) + + # The data loads back from the database correctly and 'data' has the + # right type. + m1 = MyModel.objects.get(pk=m.pk) + self.assertTrue(isinstance(m1.data, Small)) + self.assertEqual(str(m1.data), "12") + + # We can do normal filtering on the custom field (and will get an error + # when we use a lookup type that does not make sense). + s1 = Small(1, 3) + s2 = Small("a", "b") + self.assertQuerysetEqual( + MyModel.objects.filter(data__in=[s, s1, s2]), [ + "m", + ], + lambda m: m.name, + ) + self.assertRaises(TypeError, lambda: MyModel.objects.filter(data__lt=s)) + + # Serialization works, too. + stream = serializers.serialize("json", MyModel.objects.all()) + self.assertEqual(stream, '[{"pk": 1, "model": "field_subclassing.mymodel", "fields": {"data": "12", "name": "m"}}]') + + obj = list(serializers.deserialize("json", stream))[0] + self.assertEqual(obj.object, m) + + # Test retrieving custom field data + m.delete() + + m1 = MyModel.objects.create(name="1", data=Small(1, 2)) + m2 = MyModel.objects.create(name="2", data=Small(2, 3)) + + self.assertQuerysetEqual( + MyModel.objects.all(), [ + "12", + "23", + ], + lambda m: str(m.data) + ) + + def test_field_subclassing(self): + o = OtherModel.objects.create(data=Small("a", "b")) + o = OtherModel.objects.get() + self.assertEqual(o.data.first, "a") + self.assertEqual(o.data.second, "b") |