Merged regressiontests and modeltests into the test root.

4 files changed, 192 insertions, 0 deletions

diff --git a/tests/field_subclassing/__init__.py b/tests/field_subclassing/__init__.py
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/tests/field_subclassing/__init__.py
diff --git a/tests/field_subclassing/fields.py b/tests/field_subclassing/fields.py
new file mode 100644
index 0000000000..a3867e3671
--- /dev/null
+++ b/tests/field_subclassing/fields.py
@@ -0,0 +1,74 @@
+from __future__ import unicode_literals
+
+import json
+
+from django.db import models
+from django.utils.encoding import force_text
+from django.utils import six
+from django.utils.encoding import python_2_unicode_compatible
+
+
+@python_2_unicode_compatible
+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 __str__(self):
+        return '%s%s' % (force_text(self.first), force_text(self.second))
+
+class SmallField(six.with_metaclass(models.SubfieldBase, 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.
+    """
+
+    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, connection):
+        return six.text_type(value)
+
+    def get_prep_lookup(self, lookup_type, value):
+        if lookup_type == 'exact':
+            return force_text(value)
+        if lookup_type == 'in':
+            return [force_text(v) for v in value]
+        if lookup_type == 'isnull':
+            return []
+        raise TypeError('Invalid lookup type: %r' % lookup_type)
+
+class SmallerField(SmallField):
+    pass
+
+
+class JSONField(six.with_metaclass(models.SubfieldBase, models.TextField)):
+
+    description = ("JSONField automatically serializes and desializes values to "
+        "and from JSON.")
+
+    def to_python(self, value):
+        if not value:
+            return None
+
+        if isinstance(value, six.string_types):
+            value = json.loads(value)
+        return value
+
+    def get_db_prep_save(self, value, connection):
+        if value is None:
+            return None
+        return json.dumps(value)
diff --git a/tests/field_subclassing/models.py b/tests/field_subclassing/models.py
new file mode 100644
index 0000000000..642573cc83
--- /dev/null
+++ b/tests/field_subclassing/models.py
@@ -0,0 +1,26 @@
+"""
+Tests for field subclassing.
+"""
+
+from __future__ import absolute_import
+
+from django.db import models
+from django.utils.encoding import force_text
+
+from .fields import SmallField, SmallerField, JSONField
+from django.utils.encoding import python_2_unicode_compatible
+
+
+@python_2_unicode_compatible
+class MyModel(models.Model):
+    name = models.CharField(max_length=10)
+    data = SmallField('small field')
+
+    def __str__(self):
+        return force_text(self.name)
+
+class OtherModel(models.Model):
+    data = SmallerField()
+
+class DataModel(models.Model):
+    data = JSONField()
diff --git a/tests/field_subclassing/tests.py b/tests/field_subclassing/tests.py
new file mode 100644
index 0000000000..9331ff2f3f
--- /dev/null
+++ b/tests/field_subclassing/tests.py
@@ -0,0 +1,92 @@
+from __future__ import absolute_import
+
+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)
+        self.assertTrue(isinstance(d.data, list))
+        self.assertEqual(d.data, [1, 2, 3])
+        # Refetch for save
+        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.assertJSONEqual(stream, [{
+            "pk": m1.pk,
+            "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),
+            ordered=False
+        )
+
+    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")